Coverage for /usr/local/lib/python3.11/dist-packages/grond/targets/waveform/plot.py: 78%

1import logging 

2import math 

3from collections import defaultdict 

4 

5import numpy as num 

6 

7from matplotlib import pyplot as plt 

8from matplotlib import cm, patches 

9 

10from pyrocko import plot, gf, trace 

11from pyrocko.plot import mpl_init, mpl_color 

12from pyrocko.guts import Tuple, Float, Int, String 

13 

14from grond import core, meta 

15from .target import WaveformMisfitResult, WaveformMisfitTarget 

16from ..plot import StationDistributionPlot 

17 

18from grond.plot.config import PlotConfig 

19from grond.plot.common import light 

20from grond.plot.collection import PlotItem 

21 

22guts_prefix = 'grond' 

23km = 1e3 

24d2r = math.pi / 180. 

25 

26logger = logging.getLogger('targets.waveform.plot') 

27 

28 

29def make_norm_trace(a, b, exponent): 

30 tmin = max(a.tmin, b.tmin) 

31 tmax = min(a.tmax, b.tmax) 

32 c = a.chop(tmin, tmax, inplace=False) 

33 bc = b.chop(tmin, tmax, inplace=False) 

34 c.set_ydata(num.abs(c.get_ydata() - bc.get_ydata())**exponent) 

35 return c 

36 

37 

38def amp_spec_max(spec_trs, key): 

39 amaxs = {} 

40 for spec_tr in spec_trs: 

41 amax = num.max(num.abs(spec_tr.ydata)) 

42 k = key(spec_tr) 

43 if k not in amaxs: 

44 amaxs[k] = amax 

45 else: 

46 amaxs[k] = max(amaxs[k], amax) 

47 

48 return amaxs 

49 

50 

51def plot_trace(axes, tr, **kwargs): 

52 return axes.plot(tr.get_xdata(), tr.get_ydata(), **kwargs) 

53 

54 

55def plot_taper(axes, t, taper, **kwargs): 

56 y = num.ones(t.size) * 0.9 

57 taper(y, t[0], t[1] - t[0]) 

58 y2 = num.concatenate((y, -y[::-1])) 

59 t2 = num.concatenate((t, t[::-1])) 

60 axes.fill(t2, y2, **kwargs) 

61 

62 

63def plot_dtrace(axes, tr, space, mi, ma, **kwargs): 

64 t = tr.get_xdata() 

65 y = tr.get_ydata() 

66 y2 = (num.concatenate((y, num.zeros(y.size))) - mi) / \ 

67 (ma - mi) * space - (1.0 + space) 

68 t2 = num.concatenate((t, t[::-1])) 

69 axes.fill( 

70 t2, y2, 

71 clip_on=False, 

72 **kwargs) 

73 

74 

75def plot_spectrum( 

76 axes, spec_syn, spec_obs, fmin, fmax, space, mi, ma, 

77 syn_color='red', obs_color='black', 

78 syn_lw=1.5, obs_lw=1.0, color_vline='gray', fontsize=9.): 

79 

80 fpad = (fmax - fmin) / 6. 

81 

82 for spec, color, lw in [ 

83 (spec_syn, syn_color, syn_lw), 

84 (spec_obs, obs_color, obs_lw)]: 

85 

86 f = spec.get_xdata() 

87 mask = num.logical_and(fmin - fpad <= f, f <= fmax + fpad) 

88 

89 f = f[mask] 

90 y = num.abs(spec.get_ydata())[mask] 

91 

92 y2 = (num.concatenate((y, num.zeros(y.size))) - mi) / \ 

93 (ma - mi) * space - (1.0 + space) 

94 f2 = num.concatenate((f, f[::-1])) 

95 axes2 = axes.twiny() 

96 axes2.set_axis_off() 

97 

98 axes2.set_xlim(fmin - fpad * 5, fmax + fpad * 5) 

99 

100 axes2.plot(f2, y2, clip_on=False, color=color, lw=lw) 

101 axes2.fill(f2, y2, alpha=0.1, clip_on=False, color=color) 

102 

103 axes2.plot([fmin, fmin], [-1.0 - space, -1.0], color=color_vline) 

104 axes2.plot([fmax, fmax], [-1.0 - space, -1.0], color=color_vline) 

105 

106 for (text, fx, ha) in [ 

107 ('%.3g Hz' % fmin, fmin, 'right'), 

108 ('%.3g Hz' % fmax, fmax, 'left')]: 

109 

110 axes2.annotate( 

111 text, 

112 xy=(fx, -1.0), 

113 xycoords='data', 

114 xytext=( 

115 fontsize * 0.4 * [-1, 1][ha == 'left'], 

116 -fontsize * 0.2), 

117 textcoords='offset points', 

118 ha=ha, 

119 va='top', 

120 color=color_vline, 

121 fontsize=fontsize) 

122 

123 

124def plot_dtrace_vline(axes, t, space, **kwargs): 

125 axes.plot([t, t], [-1.0 - space, -1.0], **kwargs) 

126 

127 

128def layout(source, targets, nxmax, nymax): 

129 if nxmax == 1 and nymax == 1: 

130 nx = len(targets) 

131 ny = 1 

132 nxx = 1 

133 nyy = 1 

134 frame_to_target = {} 

135 for ix, target in enumerate(sorted(targets, key=lambda t: t.path)): 

136 frame_to_target[0, ix] = target 

137 

138 return frame_to_target, nx, ny, nxx, nyy 

139 

140 nframes = len(targets) 

141 

142 nx = int(math.ceil(math.sqrt(nframes))) 

143 ny = (nframes - 1) // nx + 1 

144 

145 nxx = (nx - 1) // nxmax + 1 

146 nyy = (ny - 1) // nymax + 1 

147 

148 # nz = nxx * nyy 

149 

150 xs = num.arange(nx) // ((max(2, nx) - 1.0) / 2.) 

151 ys = num.arange(ny) // ((max(2, ny) - 1.0) / 2.) 

152 

153 xs -= num.mean(xs) 

154 ys -= num.mean(ys) 

155 

156 fxs = num.tile(xs, ny) 

157 fys = num.repeat(ys, nx) 

158 

159 data = [] 

160 

161 for target in targets: 

162 azi = source.azibazi_to(target)[0] 

163 dist = source.distance_to(target) 

164 x = dist * num.sin(num.deg2rad(azi)) 

165 y = dist * num.cos(num.deg2rad(azi)) 

166 data.append((x, y, dist)) 

167 

168 gxs, gys, dists = num.array(data, dtype=float).T 

169 

170 iorder = num.argsort(dists) 

171 

172 gxs = gxs[iorder] 

173 gys = gys[iorder] 

174 targets_sorted = [targets[ii] for ii in iorder] 

175 

176 gxs -= num.mean(gxs) 

177 gys -= num.mean(gys) 

178 

179 gmax = max(num.max(num.abs(gys)), num.max(num.abs(gxs))) 

180 if gmax == 0.: 

181 gmax = 1. 

182 

183 gxs /= gmax 

184 gys /= gmax 

185 

186 dists = num.sqrt( 

187 (fxs[num.newaxis, :] - gxs[:, num.newaxis])**2 + 

188 (fys[num.newaxis, :] - gys[:, num.newaxis])**2) 

189 

190 distmax = num.max(dists) 

191 

192 availmask = num.ones(dists.shape[1], dtype=bool) 

193 frame_to_target = {} 

194 for itarget, target in enumerate(targets_sorted): 

195 iframe = num.argmin( 

196 num.where(availmask, dists[itarget], distmax + 1.)) 

197 availmask[iframe] = False 

198 iy, ix = num.unravel_index(iframe, (ny, nx)) 

199 frame_to_target[iy, ix] = target 

200 

201 return frame_to_target, nx, ny, nxx, nyy 

202 

203 

204class CheckWaveformsPlot(PlotConfig): 

205 ''' Plot for checking the waveforms fit with a number of synthetics ''' 

206 name = 'check_waveform' 

207 

208 size_cm = Tuple.T( 

209 2, Float.T(), 

210 default=(9., 7.5), 

211 help='width and length of the figure in cm') 

212 n_random_synthetics = Int.T( 

213 default=10, 

214 help='Number of Synthetics to generate') 

215 

216 def make(self, environ): 

217 cm = environ.get_plot_collection_manager() 

218 mpl_init(fontsize=self.font_size) 

219 

220 environ.setup_modelling() 

221 

222 problem = environ.get_problem() 

223 results_list = [] 

224 sources = [] 

225 if self.n_random_synthetics == 0: 

226 x = problem.preconstrain(problem.get_reference_model()) 

227 sources.append(problem.base_source) 

228 results = problem.evaluate(x) 

229 results_list.append(results) 

230 

231 else: 

232 for _ in range(self.n_random_synthetics): 

233 x = problem.get_random_model() 

234 sources.append(problem.get_source(x)) 

235 results = problem.evaluate(x) 

236 results_list.append(results) 

237 

238 cm.create_group_mpl(self, self.draw_figures( 

239 sources, problem.targets, results_list), 

240 title=u'Waveform Check', 

241 section='checks', 

242 feather_icon='activity', 

243 description=u''' 

244Plot to judge waveform time window settings and source model parameter ranges. 

245 

246For each waveform target, observed and synthetic waveforms are shown. For the 

247latter, models are randomly drawn from the configured parameter search space. 

248 

249The top panel shows the observed waveform; filtered (faint gray), and filtered 

250and tapered (black). The colored outline around the observed trace shows the 

251taper position for each drawn model in a different color. The middle panel 

252shows the filtered synthetic waveforms of the drawn models and the bottom plot 

253shows the corresponding filtered and tapered synthetic waveforms. The colors of 

254taper and synthetic traces are consistent for each random model. The given time 

255is relative to the reference event origin time. 

256''') 

257 

258 def draw_figures(self, sources, targets, results_list): 

259 results_list = list(zip(*results_list)) 

260 for itarget, target, results in zip( 

261 range(len(targets)), targets, results_list): 

262 

263 if isinstance(target, WaveformMisfitTarget) and results: 

264 item = PlotItem(name='t%i' % itarget) 

265 item.attributes['targets'] = [target.string_id()] 

266 fig = self.draw_figure(sources, target, results) 

267 if fig is not None: 

268 yield item, fig 

269 

270 def draw_figure(self, sources, target, results): 

271 t0_mean = num.mean([s.time for s in sources]) 

272 

273 # distances = [ 

274 # s.distance_to(target) for s in sources] 

275 

276 # distance_min = num.min(distances) 

277 # distance_max = num.max(distances) 

278 

279 yabsmaxs = [] 

280 

281 for result in results: 

282 if isinstance(result, WaveformMisfitResult): 

283 yabsmaxs.append( 

284 num.max(num.abs( 

285 result.filtered_obs.get_ydata()))) 

286 

287 if yabsmaxs: 

288 yabsmax = max(yabsmaxs) or 1.0 

289 else: 

290 yabsmax = None 

291 

292 fontsize = self.font_size 

293 

294 fig = plt.figure(figsize=self.size_inch) 

295 

296 labelpos = plot.mpl_margins( 

297 fig, nw=1, nh=1, w=1., h=5., 

298 units=fontsize) 

299 

300 axes = fig.add_subplot(1, 1, 1) 

301 

302 labelpos(axes, 2.5, 2.0) 

303 axes.set_frame_on(False) 

304 axes.set_ylim(1., 4.) 

305 axes.get_yaxis().set_visible(False) 

306 axes.set_title('%s' % target.string_id()) 

307 axes.set_xlabel('Time [s]') 

308 ii = 0 

309 

310 for source, result in zip(sources, results): 

311 if not isinstance(result, WaveformMisfitResult): 

312 continue 

313 

314 if result.tobs_shift != 0.0: 

315 t0 = result.tsyn_pick 

316 else: 

317 t0 = t0_mean 

318 

319 t = result.filtered_obs.get_xdata() 

320 ydata = result.filtered_obs.get_ydata() / yabsmax 

321 axes.plot( 

322 t-t0, ydata*0.40 + 3.5, color='black', lw=1.0) 

323 

324 color = plot.mpl_graph_color(ii) 

325 

326 t = result.filtered_syn.get_xdata() 

327 ydata = result.filtered_syn.get_ydata() 

328 ydata = ydata / (num.max(num.abs(ydata)) or 1.0) 

329 

330 axes.plot(t-t0, ydata*0.47 + 2.5, color=color, alpha=0.5, lw=1.0) 

331 

332 t = result.processed_syn.get_xdata() 

333 ydata = result.processed_syn.get_ydata() 

334 ydata = ydata / (num.max(num.abs(ydata)) or 1.0) 

335 

336 axes.plot(t-t0, ydata*0.47 + 1.5, color=color, alpha=0.5, lw=1.0) 

337 if result.tobs_shift != 0.0: 

338 axes.axvline( 

339 result.tsyn_pick - t0, 

340 color=(0.7, 0.7, 0.7), 

341 zorder=2) 

342 

343 t = result.processed_syn.get_xdata() 

344 taper = result.taper 

345 

346 y = num.ones(t.size) * 0.9 

347 taper(y, t[0], t[1] - t[0]) 

348 y2 = num.concatenate((y, -y[::-1])) 

349 t2 = num.concatenate((t, t[::-1])) 

350 axes.plot(t2-t0, y2 * 0.47 + 3.5, color=color, alpha=0.2, lw=1.0) 

351 ii += 1 

352 

353 return fig 

354 

355 

356class FitsWaveformEnsemblePlot(PlotConfig): 

357 ''' Plot showing all waveform fits for the ensemble of solutions''' 

358 

359 name = 'fits_waveform_ensemble' 

360 size_cm = Tuple.T( 

361 2, Float.T(), 

362 default=(9., 5.), 

363 help='width and length of the figure in cm') 

364 nx = Int.T( 

365 default=1, 

366 help='horizontal number of subplots on every page') 

367 ny = Int.T( 

368 default=1, 

369 help='vertical number of subplots on every page') 

370 misfit_cutoff = Float.T( 

371 optional=True, 

372 help='Plot fits for models up to this misfit value') 

373 color_parameter = String.T( 

374 default='misfit', 

375 help='Choice of value to color, options: dist and misfit') 

376 font_size = Float.T( 

377 default=8, 

378 help='Font Size of all fonts, except title') 

379 font_size_title = Float.T( 

380 default=10, 

381 help='Font size of title') 

382 

383 def make(self, environ): 

384 cm = environ.get_plot_collection_manager() 

385 mpl_init(fontsize=self.font_size) 

386 environ.setup_modelling() 

387 ds = environ.get_dataset() 

388 history = environ.get_history(subset='harvest') 

389 optimiser = environ.get_optimiser() 

390 

391 cm.create_group_mpl( 

392 self, 

393 self.draw_figures(ds, history, optimiser), 

394 title=u'Waveform fits for the ensemble', 

395 section='fits', 

396 feather_icon='activity', 

397 description=u''' 

398Plot showing waveform (attribute) fits for the ensemble of solutions. 

399 

400Waveform fits for every nth model in the ensemble of bootstrap solutions. 

401Depending on the target configuration different types of comparisons are 

402possible: (i) time domain waveform differences, (ii) amplitude spectra, (iii) 

403envelopes, (iv) cross correlation functions. Each waveform plot gives a number 

404of details: 

405 

4061) Target information (left side, from top to bottom) gives station name with 

407component, distance to source, azimuth of station with respect to source, 

408target weight, target misfit and starting time of the waveform relative to the 

409origin time. 

410 

4112) The background gray area shows the applied taper function. 

412 

4133) The waveforms shown are: the restituted and filtered observed trace without 

414tapering (light grey) and the same trace with tapering and processing (dark 

415gray), the synthetic trace (light red) and the filtered, tapered and (if 

416enabled) shifted and processed synthetic trace (colored). The colors of the 

417synthetic traces indicate how well the corresponding models fit in the global 

418weighting scheme (when all bootstrap weights are equal), from better fit (red) 

419to worse fit (blue). The amplitudes of the traces are scaled according to the 

420target weight (small weight, small amplitude) and normed relative to the 

421maximum amplitude of the targets of the corresponding normalisation family. 

422 

4234) The bottom panel shows, depending on the type of comparison, sample-wise 

424residuals for time domain comparisons (red filled), spectra of observed and 

425synthetic traces for amplitude spectrum comparisons, or cross correlation 

426traces.''') 

427 

428 def draw_figures(self, ds, history, optimiser): 

429 

430 color_parameter = self.color_parameter 

431 misfit_cutoff = self.misfit_cutoff 

432 fontsize = self.font_size 

433 fontsize_title = self.font_size_title 

434 

435 nxmax = self.nx 

436 nymax = self.ny 

437 

438 problem = history.problem 

439 

440 for target in problem.targets: 

441 target.set_dataset(ds) 

442 

443 target_index = {} 

444 i = 0 

445 for target in problem.targets: 

446 target_index[target] = i, i+target.nmisfits 

447 i += target.nmisfits 

448 

449 gms = history.get_sorted_primary_misfits()[::-1] 

450 models = history.get_sorted_primary_models()[::-1] 

451 

452 if misfit_cutoff is not None: 

453 ibest = gms < misfit_cutoff 

454 gms = gms[ibest] 

455 models = models[ibest] 

456 

457 gms = gms[::10] 

458 models = models[::10] 

459 

460 nmodels = models.shape[0] 

461 if color_parameter == 'dist': 

462 mx = num.mean(models, axis=0) 

463 cov = num.cov(models.T) 

464 mdists = core.mahalanobis_distance(models, mx, cov) 

465 icolor = meta.ordersort(mdists) 

466 

467 elif color_parameter == 'misfit': 

468 iorder = num.arange(nmodels) 

469 icolor = iorder 

470 

471 elif color_parameter in problem.parameter_names: 

472 ind = problem.name_to_index(color_parameter) 

473 icolor = problem.extract(models, ind) 

474 

475 target_to_results = defaultdict(list) 

476 all_syn_trs = [] 

477 

478 dtraces = [] 

479 for imodel in range(nmodels): 

480 model = models[imodel, :] 

481 

482 source = problem.get_source(model) 

483 results = problem.evaluate(model) 

484 

485 dtraces.append([]) 

486 

487 for target, result in zip(problem.targets, results): 

488 w = target.get_combined_weight() 

489 

490 if isinstance(result, gf.SeismosizerError) or \ 

491 not isinstance(target, WaveformMisfitTarget) or \ 

492 not num.all(num.isfinite(w)): 

493 

494 dtraces[-1].extend([None] * target.nmisfits) 

495 continue 

496 

497 itarget, itarget_end = target_index[target] 

498 assert itarget_end == itarget + 1 

499 

500 if target.misfit_config.domain == 'cc_max_norm': 

501 tref = ( 

502 result.filtered_obs.tmin + result.filtered_obs.tmax) \ 

503 * 0.5 

504 

505 for tr_filt, tr_proc, tshift in ( 

506 (result.filtered_obs, 

507 result.processed_obs, 

508 0.), 

509 (result.filtered_syn, 

510 result.processed_syn, 

511 result.tshift)): 

512 

513 norm = num.sum(num.abs(tr_proc.ydata)) \ 

514 / tr_proc.data_len() 

515 tr_filt.ydata /= norm 

516 tr_proc.ydata /= norm 

517 

518 tr_filt.shift(tshift) 

519 tr_proc.shift(tshift) 

520 

521 ctr = result.cc 

522 ctr.shift(tref) 

523 

524 dtrace = ctr 

525 

526 else: 

527 for tr in ( 

528 result.filtered_obs, 

529 result.filtered_syn, 

530 result.processed_obs, 

531 result.processed_syn): 

532 

533 tr.ydata *= w 

534 

535 if result.tshift is not None and result.tshift != 0.0: 

536 # result.filtered_syn.shift(result.tshift) 

537 result.processed_syn.shift(result.tshift) 

538 

539 dtrace = make_norm_trace( 

540 result.processed_syn, result.processed_obs, 

541 problem.norm_exponent) 

542 

543 target_to_results[target].append(result) 

544 

545 dtrace.meta = dict( 

546 normalisation_family=target.normalisation_family, 

547 path=target.path) 

548 

549 dtraces[-1].append(dtrace) 

550 

551 result.processed_syn.meta = dict( 

552 normalisation_family=target.normalisation_family, 

553 path=target.path) 

554 

555 all_syn_trs.append(result.processed_syn) 

556 

557 if not all_syn_trs: 

558 logger.warning('No traces to show!') 

559 return 

560 

561 def skey(tr): 

562 return tr.meta['normalisation_family'], tr.meta['path'] 

563 

564 trace_minmaxs = trace.minmax(all_syn_trs, skey) 

565 

566 dtraces_all = [] 

567 for dtraces_group in dtraces: 

568 dtraces_all.extend(dtraces_group) 

569 

570 dminmaxs = trace.minmax([ 

571 dtrace_ for dtrace_ in dtraces_all if dtrace_ is not None], skey) 

572 

573 for tr in dtraces_all: 

574 if tr: 

575 dmin, dmax = dminmaxs[skey(tr)] 

576 tr.ydata /= max(abs(dmin), abs(dmax)) 

577 

578 cg_to_targets = meta.gather( 

579 problem.waveform_targets, 

580 lambda t: (t.path, t.codes[3]), 

581 filter=lambda t: t in target_to_results) 

582 

583 cgs = sorted(cg_to_targets.keys()) 

584 

585 from matplotlib import colors 

586 cmap = cm.ScalarMappable( 

587 norm=colors.Normalize(vmin=num.min(icolor), vmax=num.max(icolor)), 

588 cmap=plt.get_cmap('coolwarm')) 

589 

590 imodel_to_color = [] 

591 for imodel in range(nmodels): 

592 imodel_to_color.append(cmap.to_rgba(icolor[imodel])) 

593 

594 for cg in cgs: 

595 targets = cg_to_targets[cg] 

596 

597 frame_to_target, nx, ny, nxx, nyy = layout( 

598 source, targets, nxmax, nymax) 

599 

600 figures = {} 

601 for iy in range(ny): 

602 for ix in range(nx): 

603 if (iy, ix) not in frame_to_target: 

604 continue 

605 

606 ixx = ix // nxmax 

607 iyy = iy // nymax 

608 if (iyy, ixx) not in figures: 

609 title = '_'.join(x for x in cg if x) 

610 item = PlotItem( 

611 name='fig_%s_%i_%i' % (title, ixx, iyy)) 

612 item.attributes['targets'] = [] 

613 figures[iyy, ixx] = ( 

614 item, plt.figure(figsize=self.size_inch)) 

615 

616 figures[iyy, ixx][1].subplots_adjust( 

617 left=0.03, 

618 right=1.0 - 0.03, 

619 bottom=0.03, 

620 top=1.0 - 0.06, 

621 wspace=0.2, 

622 hspace=0.2) 

623 

624 item, fig = figures[iyy, ixx] 

625 

626 target = frame_to_target[iy, ix] 

627 

628 item.attributes['targets'].append(target.string_id()) 

629 

630 amin, amax = trace_minmaxs[ 

631 target.normalisation_family, target.path] 

632 absmax = max(abs(amin), abs(amax)) 

633 

634 ny_this = nymax # min(ny, nymax) 

635 nx_this = nxmax # min(nx, nxmax) 

636 i_this = (iy % ny_this) * nx_this + (ix % nx_this) + 1 

637 

638 axes2 = fig.add_subplot(ny_this, nx_this, i_this) 

639 

640 space = 0.5 

641 space_factor = 1.0 + space 

642 axes2.set_axis_off() 

643 axes2.set_ylim(-1.05 * space_factor, 1.05) 

644 

645 axes = axes2.twinx() 

646 axes.set_axis_off() 

647 

648 if target.misfit_config.domain == 'cc_max_norm': 

649 axes.set_ylim(-10. * space_factor, 10.) 

650 else: 

651 axes.set_ylim(-absmax*1.33 * space_factor, absmax*1.33) 

652 

653 itarget, itarget_end = target_index[target] 

654 assert itarget_end == itarget + 1 

655 

656 for imodel, result in enumerate(target_to_results[target]): 

657 

658 syn_color = imodel_to_color[imodel] 

659 

660 dtrace = dtraces[imodel][itarget] 

661 

662 tap_color_annot = (0.35, 0.35, 0.25) 

663 tap_color_edge = (0.85, 0.85, 0.80) 

664 tap_color_fill = (0.95, 0.95, 0.90) 

665 

666 plot_taper( 

667 axes2, 

668 result.processed_obs.get_xdata(), 

669 result.taper, 

670 fc=tap_color_fill, ec=tap_color_edge, alpha=0.2) 

671 

672 obs_color = mpl_color('aluminium5') 

673 obs_color_light = light(obs_color, 0.5) 

674 

675 plot_dtrace( 

676 axes2, dtrace, space, 0., 1., 

677 fc='none', 

678 ec=syn_color) 

679 

680 # plot_trace( 

681 # axes, result.filtered_syn, 

682 # color=syn_color_light, lw=1.0) 

683 

684 if imodel == 0: 

685 plot_trace( 

686 axes, result.filtered_obs, 

687 color=obs_color_light, lw=0.75) 

688 

689 plot_trace( 

690 axes, result.processed_syn, 

691 color=syn_color, lw=1.0, alpha=0.3) 

692 

693 plot_trace( 

694 axes, result.processed_obs, 

695 color=obs_color, lw=0.75, alpha=0.3) 

696 

697 if imodel != 0: 

698 continue 

699 xdata = result.filtered_obs.get_xdata() 

700 axes.set_xlim(xdata[0], xdata[-1]) 

701 

702 tmarks = [ 

703 result.processed_obs.tmin, 

704 result.processed_obs.tmax] 

705 

706 for tmark in tmarks: 

707 axes2.plot( 

708 [tmark, tmark], [-0.9, 0.1], 

709 color=tap_color_annot) 

710 

711 dur = tmarks[1] - tmarks[0] 

712 for tmark, text, ha in [ 

713 (tmarks[0], 

714 '$\\,$ ' + meta.str_duration( 

715 tmarks[0] - source.time), 

716 'left'), 

717 (tmarks[1], 

718 '$\\Delta$ ' + meta.str_duration( 

719 dur), 

720 'right')]: 

721 

722 axes2.annotate( 

723 text, 

724 xy=(tmark, -0.9), 

725 xycoords='data', 

726 xytext=( 

727 fontsize*0.4 * [-1, 1][ha == 'left'], 

728 fontsize*0.2), 

729 textcoords='offset points', 

730 ha=ha, 

731 va='bottom', 

732 color=tap_color_annot, 

733 fontsize=fontsize) 

734 

735 axes2.set_xlim( 

736 tmarks[0] - dur*0.1, tmarks[1] + dur*0.1) 

737 

738 scale_string = None 

739 

740 if target.misfit_config.domain == 'cc_max_norm': 

741 scale_string = 'Syn/obs scales differ!' 

742 

743 infos = [] 

744 if scale_string: 

745 infos.append(scale_string) 

746 

747 if self.nx == 1 and self.ny == 1: 

748 infos.append(target.string_id())