Coverage for pesummary/core/plots/main.py: 74.7%

1#! /usr/bin/env python 

2 

3# Licensed under an MIT style license -- see LICENSE.md 

4 

5import numpy as np 

6import os 

7import importlib 

8from multiprocessing import Pool 

9 

10from pesummary.core.plots.latex_labels import latex_labels 

11from pesummary.utils.utils import ( 

12 logger, get_matplotlib_backend, make_dir, get_matplotlib_style_file 

13) 

14from pesummary.core.plots import plot as core 

15from pesummary.core.plots import interactive 

16 

17import matplotlib 

18 

19__author__ = ["Charlie Hoy <charlie.hoy@ligo.org>"] 

20matplotlib.use(get_matplotlib_backend(parallel=True)) 

21matplotlib.style.use(get_matplotlib_style_file()) 

22 

23 

24class _PlotGeneration(object): 

25 """Super class to handle the plot generation for a given set of result 

26 files 

27 

28 Parameters 

29 ---------- 

30 savedir: str 

31 the directory to store the plots 

32 webdir: str 

33 the web directory of the run 

34 labels: list 

35 list of labels used to distinguish the result files 

36 samples: dict 

37 dictionary of posterior samples stored in the result files 

38 kde_plot: Bool 

39 if True, kde plots are generated instead of histograms, Default False 

40 existing_labels: list 

41 list of labels stored in an existing metafile 

42 existing_injection_data: dict 

43 dictionary of injection data stored in an existing metafile 

44 existing_samples: dict 

45 dictionary of posterior samples stored in an existing metafile 

46 same_parameters: list 

47 list of paramerers that are common in all result files 

48 injection_data: dict 

49 dictionary of injection data for each result file 

50 result_files: list 

51 list of result files passed 

52 colors: list 

53 colors that you wish to use to distinguish different result files 

54 disable_comparison: bool, optional 

55 whether to make comparison plots, default is True. 

56 if disable_comparison is False and len(labels) == 1, no comparsion plots 

57 will be generated 

58 disable_interactive: bool, optional 

59 whether to make interactive plots, default is False 

60 disable_corner: bool, optional 

61 whether to make the corner plot, default is False 

62 """ 

63 def __init__( 

64 self, savedir=None, webdir=None, labels=None, samples=None, 

65 kde_plot=False, existing_labels=None, existing_injection_data=None, 

66 existing_samples=None, existing_weights=None, same_parameters=None, 

67 injection_data=None, colors=None, custom_plotting=None, 

68 add_to_existing=False, priors={}, include_prior=False, weights=None, 

69 disable_comparison=False, linestyles=None, disable_interactive=False, 

70 multi_process=1, mcmc_samples=False, disable_corner=False, 

71 corner_params=None, expert_plots=True, checkpoint=False, key_data=None 

72 ): 

73 self.package = "core" 

74 self.webdir = webdir 

75 make_dir(self.webdir) 

76 make_dir(os.path.join(self.webdir, "plots", "corner")) 

77 self.savedir = savedir 

78 self.labels = labels 

79 self.mcmc_samples = mcmc_samples 

80 self.samples = samples 

81 self.kde_plot = kde_plot 

82 self.existing_labels = existing_labels 

83 self.existing_injection_data = existing_injection_data 

84 self.existing_samples = existing_samples 

85 self.existing_weights = existing_weights 

86 self.same_parameters = same_parameters 

87 self.injection_data = injection_data 

88 self.colors = colors 

89 self.custom_plotting = custom_plotting 

90 self.add_to_existing = add_to_existing 

91 self.priors = priors 

92 self.include_prior = include_prior 

93 self.linestyles = linestyles 

94 self.make_interactive = not disable_interactive 

95 self.make_corner = not disable_corner 

96 self.corner_params = corner_params 

97 self.expert_plots = expert_plots 

98 if self.mcmc_samples and self.expert_plots: 

99 logger.warning("Unable to generate expert plots for mcmc samples") 

100 self.expert_plots = False 

101 self.checkpoint = checkpoint 

102 self.key_data = key_data 

103 self.multi_process = multi_process 

104 self.pool = self.setup_pool() 

105 self.preliminary_pages = {label: False for label in self.labels} 

106 self.preliminary_comparison_pages = False 

107 self.make_comparison = ( 

108 not disable_comparison and self._total_number_of_labels > 1 

109 ) 

110 self.weights = ( 

111 weights if weights is not None else {i: None for i in self.labels} 

112 ) 

113 

114 if self.same_parameters is not None and not self.mcmc_samples: 

115 self.same_samples = { 

116 param: { 

117 key: item[param] for key, item in self.samples.items() 

118 } for param in self.same_parameters 

119 } 

120 else: 

121 self.same_samples = None 

122 

123 for i in self.samples.keys(): 

124 try: 

125 self.check_latex_labels( 

126 self.samples[i].keys(remove_debug=False) 

127 ) 

128 except TypeError: 

129 try: 

130 self.check_latex_labels(self.samples[i].keys()) 

131 except TypeError: 

132 pass 

133 

134 self.plot_type_dictionary = { 

135 "oned_histogram": self.oned_histogram_plot, 

136 "sample_evolution": self.sample_evolution_plot, 

137 "autocorrelation": self.autocorrelation_plot, 

138 "oned_cdf": self.oned_cdf_plot, 

139 "custom": self.custom_plot 

140 } 

141 if self.make_corner: 

142 self.plot_type_dictionary.update({"corner": self.corner_plot}) 

143 if self.expert_plots: 

144 self.plot_type_dictionary.update({"expert": self.expert_plot}) 

145 if self.make_comparison: 

146 self.plot_type_dictionary.update(dict( 

147 oned_histogram_comparison=self.oned_histogram_comparison_plot, 

148 oned_cdf_comparison=self.oned_cdf_comparison_plot, 

149 box_plot_comparison=self.box_plot_comparison_plot, 

150 )) 

151 if self.make_interactive: 

152 self.plot_type_dictionary.update( 

153 dict( 

154 interactive_corner=self.interactive_corner_plot 

155 ) 

156 ) 

157 if self.make_comparison: 

158 self.plot_type_dictionary.update( 

159 dict( 

160 interactive_ridgeline=self.interactive_ridgeline_plot 

161 ) 

162 ) 

163 

164 @staticmethod 

165 def save(fig, name, preliminary=False, close=True, format="png"): 

166 """Save a figure to disk. 

167 

168 Parameters 

169 ---------- 

170 fig: matplotlib.pyplot.figure 

171 Matplotlib figure that you wish to save 

172 name: str 

173 Name of the file that you wish to write it too 

174 close: Bool, optional 

175 Close the figure after it has been saved 

176 format: str, optional 

177 Format used to save the image 

178 """ 

179 n = len(format) 

180 if ".%s" % (format) != name[-n - 1:]: 

181 name += ".%s" % (format) 

182 if preliminary: 

183 fig.text( 

184 0.5, 0.5, 'Preliminary', fontsize=90, color='gray', alpha=0.1, 

185 ha='center', va='center', rotation=30 

186 ) 

187 fig.tight_layout() 

188 fig.savefig(name, format=format) 

189 if close: 

190 fig.close() 

191 

192 @property 

193 def _total_number_of_labels(self): 

194 _number_of_labels = 0 

195 for item in [self.labels, self.existing_labels]: 

196 if isinstance(item, list): 

197 _number_of_labels += len(item) 

198 return _number_of_labels 

199 

200 @staticmethod 

201 def check_latex_labels(parameters): 

202 """Check to see if there is a latex label for all parameters. If not, 

203 then create one 

204 

205 Parameters 

206 ---------- 

207 parameters: list 

208 list of parameters 

209 """ 

210 for i in parameters: 

211 if i not in list(latex_labels.keys()): 

212 latex_labels[i] = i.replace("_", " ") 

213 

214 @property 

215 def savedir(self): 

216 return self._savedir 

217 

218 @savedir.setter 

219 def savedir(self, savedir): 

220 self._savedir = savedir 

221 if savedir is None: 

222 self._savedir = self.webdir + "/plots/" 

223 

224 def setup_pool(self): 

225 """Setup a pool of processes to speed up plot generation 

226 """ 

227 pool = Pool(processes=self.multi_process) 

228 return pool 

229 

230 def generate_plots(self): 

231 """Generate all plots for all result files 

232 """ 

233 for i in self.labels: 

234 logger.debug("Starting to generate plots for {}".format(i)) 

235 self._generate_plots(i) 

236 if self.make_interactive: 

237 logger.debug( 

238 "Starting to generate interactive plots for {}".format(i) 

239 ) 

240 self._generate_interactive_plots(i) 

241 if self.add_to_existing: 

242 self.add_existing_data() 

243 if self.make_comparison: 

244 logger.debug("Starting to generate comparison plots") 

245 self._generate_comparison_plots() 

246 

247 def check_key_data_in_dict(self, label, param): 

248 """Check to see if there is key data for a given param 

249 

250 Parameters 

251 ---------- 

252 label: str 

253 the label used to distinguish a given run 

254 param: str 

255 name of the parameter you wish to return prior samples for 

256 """ 

257 if self.key_data is None: 

258 return None 

259 elif label not in self.key_data.keys(): 

260 return None 

261 elif param not in self.key_data[label].keys(): 

262 return None 

263 return self.key_data[label][param] 

264 

265 def check_prior_samples_in_dict(self, label, param): 

266 """Check to see if there are prior samples for a given param 

267 

268 Parameters 

269 ---------- 

270 label: str 

271 the label used to distinguish a given run 

272 param: str 

273 name of the parameter you wish to return prior samples for 

274 """ 

275 cond1 = "samples" in self.priors.keys() 

276 if cond1 and label in self.priors["samples"].keys(): 

277 cond1 = self.priors["samples"][label] != [] 

278 if cond1 and param in self.priors["samples"][label].keys(): 

279 return self.priors["samples"][label][param] 

280 return None 

281 return None 

282 

283 def add_existing_data(self): 

284 """ 

285 """ 

286 from pesummary.utils.utils import _add_existing_data 

287 

288 self = _add_existing_data(self) 

289 

290 def _generate_plots(self, label): 

291 """Generate all plots for a a given result file 

292 """ 

293 if self.make_corner: 

294 self.try_to_make_a_plot("corner", label=label) 

295 self.try_to_make_a_plot("oned_histogram", label=label) 

296 self.try_to_make_a_plot("sample_evolution", label=label) 

297 self.try_to_make_a_plot("autocorrelation", label=label) 

298 self.try_to_make_a_plot("oned_cdf", label=label) 

299 if self.expert_plots: 

300 self.try_to_make_a_plot("expert", label=label) 

301 if self.custom_plotting: 

302 self.try_to_make_a_plot("custom", label=label) 

303 

304 def _generate_interactive_plots(self, label): 

305 """Generate all interactive plots and save them to an html file ready 

306 to be imported later 

307 """ 

308 self.try_to_make_a_plot("interactive_corner", label=label) 

309 if self.make_comparison: 

310 self.try_to_make_a_plot("interactive_ridgeline") 

311 

312 def _generate_comparison_plots(self): 

313 """Generate all comparison plots 

314 """ 

315 self.try_to_make_a_plot("oned_histogram_comparison") 

316 self.try_to_make_a_plot("oned_cdf_comparison") 

317 self.try_to_make_a_plot("box_plot_comparison") 

318 

319 def try_to_make_a_plot(self, plot_type, label=None): 

320 """Wrapper function to _try_to_make_a_plot 

321 

322 Parameters 

323 ---------- 

324 plot_type: str 

325 String to describe the plot that you wish to try and make 

326 label: str 

327 The label of the results file that you wish to plot 

328 """ 

329 self._try_to_make_a_plot( 

330 [label], self.plot_type_dictionary[plot_type], 

331 "Failed to generate %s plot because {}" % (plot_type) 

332 ) 

333 

334 @staticmethod 

335 def _try_to_make_a_plot(arguments, function, message): 

336 """Try to make a plot. If it fails return an error message and continue 

337 plotting 

338 

339 Parameters 

340 ---------- 

341 arguments: list 

342 list of arguments that you wish to pass to function 

343 function: func 

344 function that you wish to execute 

345 message: str 

346 the error message that you wish to be printed. 

347 """ 

348 try: 

349 function(*arguments) 

350 except RuntimeError: 

351 try: 

352 from matplotlib import rcParams 

353 

354 original = rcParams['text.usetex'] 

355 rcParams['text.usetex'] = False 

356 function(*arguments) 

357 rcParams['text.usetex'] = original 

358 except Exception as e: 

359 logger.info(message.format(e)) 

360 except Exception as e: 

361 logger.info(message.format(e)) 

362 finally: 

363 from matplotlib import pyplot 

364 

365 pyplot.close() 

366 

367 def corner_plot(self, label): 

368 """Generate a corner plot for a given result file 

369 

370 Parameters 

371 ---------- 

372 label: str 

373 the label for the results file that you wish to plot 

374 """ 

375 if self.mcmc_samples: 

376 samples = self.samples[label].combine 

377 else: 

378 samples = self.samples[label] 

379 self._corner_plot( 

380 self.savedir, label, samples, latex_labels, self.webdir, 

381 self.corner_params, self.preliminary_pages[label], self.checkpoint 

382 ) 

383 

384 @staticmethod 

385 def _corner_plot( 

386 savedir, label, samples, latex_labels, webdir, params, preliminary=False, 

387 checkpoint=False 

388 ): 

389 """Generate a corner plot for a given set of samples 

390 

391 Parameters 

392 ---------- 

393 savedir: str 

394 the directory you wish to save the plot in 

395 label: str 

396 the label corresponding to the results file 

397 samples: dict 

398 dictionary containing PESummary.utils.array.Array objects that 

399 contain samples for each parameter 

400 latex_labels: str 

401 latex labels for each parameter in samples 

402 webdir: str 

403 the directory where the `js` directory is located 

404 preliminary: Bool, optional 

405 if True, add a preliminary watermark to the plot 

406 """ 

407 import warnings 

408 

409 with warnings.catch_warnings(): 

410 warnings.simplefilter("ignore") 

411 filename = os.path.join( 

412 savedir, "corner", "{}_all_density_plots.png".format(label) 

413 ) 

414 if os.path.isfile(filename) and checkpoint: 

415 return 

416 fig, params, data = core._make_corner_plot( 

417 samples, latex_labels, corner_parameters=params 

418 ) 

419 _PlotGeneration.save( 

420 fig, filename, preliminary=preliminary 

421 ) 

422 combine_corner = open( 

423 os.path.join(webdir, "js", "combine_corner.js") 

424 ) 

425 combine_corner = combine_corner.readlines() 

426 params = [str(i) for i in params] 

427 ind = [ 

428 linenumber for linenumber, line in enumerate(combine_corner) 

429 if "var list = {}" in line 

430 ][0] 

431 combine_corner.insert( 

432 ind + 1, " list['{}'] = {};\n".format(label, params) 

433 ) 

434 new_file = open( 

435 os.path.join(webdir, "js", "combine_corner.js"), "w" 

436 ) 

437 new_file.writelines(combine_corner) 

438 new_file.close() 

439 combine_corner = open( 

440 os.path.join(webdir, "js", "combine_corner.js") 

441 ) 

442 combine_corner = combine_corner.readlines() 

443 params = [str(i) for i in params] 

444 ind = [ 

445 linenumber for linenumber, line in enumerate(combine_corner) 

446 if "var data = {}" in line 

447 ][0] 

448 combine_corner.insert( 

449 ind + 1, " data['{}'] = {};\n".format(label, data) 

450 ) 

451 new_file = open( 

452 os.path.join(webdir, "js", "combine_corner.js"), "w" 

453 ) 

454 new_file.writelines(combine_corner) 

455 new_file.close() 

456 

457 def _mcmc_iterator(self, label, function): 

458 """If the data is a set of mcmc chains, return a 2d list of samples 

459 to plot. Otherwise return a list of posterior samples 

460 """ 

461 if self.mcmc_samples: 

462 function += "_mcmc" 

463 return self.same_parameters, self.samples[label], getattr( 

464 self, function 

465 ) 

466 return self.samples[label].keys(), self.samples[label], getattr( 

467 self, function 

468 ) 

469 

470 def oned_histogram_plot(self, label): 

471 """Generate oned histogram plots for all parameters in the result file 

472 

473 Parameters 

474 ---------- 

475 label: str 

476 the label for the results file that you wish to plot 

477 """ 

478 error_message = ( 

479 "Failed to generate oned_histogram plot for %s because {}" 

480 ) 

481 

482 iterator, samples, function = self._mcmc_iterator( 

483 label, "_oned_histogram_plot" 

484 ) 

485 

486 prior = lambda param: self.check_prior_samples_in_dict( 

487 label, param 

488 ) if self.include_prior else None 

489 key_data = lambda label, param: self.check_key_data_in_dict(label, param) 

490 

491 arguments = [ 

492 ( 

493 [ 

494 self.savedir, label, param, samples[param], 

495 latex_labels[param], self.injection_data[label][param], 

496 self.kde_plot, prior(param), self.weights[label], 

497 self.package, self.preliminary_pages[label], 

498 self.checkpoint, key_data(label, param) 

499 ], function, error_message % (param) 

500 ) for param in iterator 

501 ] 

502 self.pool.starmap(self._try_to_make_a_plot, arguments) 

503 

504 def oned_histogram_comparison_plot(self, label): 

505 """Generate oned comparison histogram plots for all parameters that are 

506 common to all result files 

507 

508 Parameters 

509 ---------- 

510 label: str 

511 the label for the results file that you wish to plot 

512 """ 

513 error_message = ( 

514 "Failed to generate a comparison histogram plot for %s because {}" 

515 ) 

516 for param in self.same_parameters: 

517 injection = [ 

518 value[param] for value in self.injection_data.values() 

519 ] 

520 arguments = [ 

521 self.savedir, param, self.same_samples[param], 

522 latex_labels[param], self.colors, injection, self.kde_plot, 

523 self.linestyles, self.package, 

524 self.preliminary_comparison_pages, self.checkpoint, None 

525 ] 

526 self._try_to_make_a_plot( 

527 arguments, self._oned_histogram_comparison_plot, 

528 error_message % (param) 

529 ) 

530 continue 

531 

532 @staticmethod 

533 def _oned_histogram_comparison_plot( 

534 savedir, parameter, samples, latex_label, colors, injection, kde=False, 

535 linestyles=None, package="core", preliminary=False, checkpoint=False, 

536 filename=None 

537 ): 

538 """Generate a oned comparison histogram plot for a given parameter 

539 

540 Parameters 

541 ----------i 

542 savedir: str 

543 the directory you wish to save the plot in 

544 parameter: str 

545 the name of the parameter that you wish to make a oned comparison 

546 histogram for 

547 samples: dict 

548 dictionary of pesummary.utils.array.Array objects containing the 

549 samples that correspond to parameter for each result file. The key 

550 should be the corresponding label 

551 latex_label: str 

552 the latex label for parameter 

553 colors: list 

554 list of colors to be used to distinguish different result files 

555 injection: list 

556 list of injected values, one for each analysis 

557 kde: Bool, optional 

558 if True, kde plots will be generated rather than 1d histograms 

559 linestyles: list, optional 

560 list of linestyles used to distinguish different result files 

561 preliminary: Bool, optional 

562 if True, add a preliminary watermark to the plot 

563 """ 

564 import math 

565 module = importlib.import_module( 

566 "pesummary.{}.plots.plot".format(package) 

567 ) 

568 if filename is None: 

569 filename = os.path.join( 

570 savedir, "combined_1d_posterior_{}.png".format(parameter) 

571 ) 

572 if os.path.isfile(filename) and checkpoint: 

573 return 

574 hist = not kde 

575 for num, inj in enumerate(injection): 

576 if math.isnan(inj): 

577 injection[num] = None 

578 same_samples = [val for key, val in samples.items()] 

579 fig = module._1d_comparison_histogram_plot( 

580 parameter, same_samples, colors, latex_label, 

581 list(samples.keys()), inj_value=injection, kde=kde, 

582 linestyles=linestyles, hist=hist 

583 ) 

584 _PlotGeneration.save( 

585 fig, filename, preliminary=preliminary 

586 ) 

587 

588 @staticmethod 

589 def _oned_histogram_plot( 

590 savedir, label, parameter, samples, latex_label, injection, kde=False, 

591 prior=None, weights=None, package="core", preliminary=False, 

592 checkpoint=False, key_data=None 

593 ): 

594 """Generate a oned histogram plot for a given set of samples 

595 

596 Parameters 

597 ---------- 

598 savedir: str 

599 the directory you wish to save the plot in 

600 label: str 

601 the label corresponding to the results file 

602 parameter: str 

603 the name of the parameter that you wish to plot 

604 samples: PESummary.utils.array.Array 

605 array containing the samples corresponding to parameter 

606 latex_label: str 

607 the latex label corresponding to parameter 

608 injection: float 

609 the injected value 

610 kde: Bool, optional 

611 if True, kde plots will be generated rather than 1d histograms 

612 prior: PESummary.utils.array.Array, optional 

613 the prior samples for param 

614 weights: PESummary.utils.utilsrray, optional 

615 the weights for each samples. If None, assumed to be 1 

616 preliminary: Bool, optional 

617 if True, add a preliminary watermark to the plot 

618 """ 

619 import math 

620 module = importlib.import_module( 

621 "pesummary.{}.plots.plot".format(package) 

622 ) 

623 

624 if math.isnan(injection): 

625 injection = None 

626 hist = not kde 

627 

628 filename = os.path.join( 

629 savedir, "{}_1d_posterior_{}.png".format(label, parameter) 

630 ) 

631 if os.path.isfile(filename) and checkpoint: 

632 return 

633 fig = module._1d_histogram_plot( 

634 parameter, samples, latex_label, inj_value=injection, kde=kde, 

635 hist=hist, prior=prior, weights=weights, key_data=key_data 

636 ) 

637 _PlotGeneration.save( 

638 fig, filename, preliminary=preliminary 

639 ) 

640 

641 @staticmethod 

642 def _oned_histogram_plot_mcmc( 

643 savedir, label, parameter, samples, latex_label, injection, kde=False, 

644 prior=None, weights=None, package="core", preliminary=False, 

645 checkpoint=False, key_data=None 

646 ): 

647 """Generate a oned histogram plot for a given set of samples for 

648 multiple mcmc chains 

649 

650 Parameters 

651 ---------- 

652 savedir: str 

653 the directory you wish to save the plot in 

654 label: str 

655 the label corresponding to the results file 

656 parameter: str 

657 the name of the parameter that you wish to plot 

658 samples: dict 

659 dictionary of PESummary.utils.array.Array objects containing the 

660 samples corresponding to parameter for multiple mcmc chains 

661 latex_label: str 

662 the latex label corresponding to parameter 

663 injection: float 

664 the injected value 

665 kde: Bool, optional 

666 if True, kde plots will be generated rather than 1d histograms 

667 prior: PESummary.utils.array.Array, optional 

668 the prior samples for param 

669 weights: PESummary.utils.array.Array, optional 

670 the weights for each samples. If None, assumed to be 1 

671 preliminary: Bool, optional 

672 if True, add a preliminary watermark to the plot 

673 """ 

674 import math 

675 from pesummary.utils.array import Array 

676 

677 module = importlib.import_module( 

678 "pesummary.{}.plots.plot".format(package) 

679 ) 

680 

681 if math.isnan(injection): 

682 injection = None 

683 same_samples = [val for key, val in samples.items()] 

684 filename = os.path.join( 

685 savedir, "{}_1d_posterior_{}.png".format(label, parameter) 

686 ) 

687 if os.path.isfile(filename) and checkpoint: 

688 pass 

689 else: 

690 fig = module._1d_histogram_plot_mcmc( 

691 parameter, same_samples, latex_label, inj_value=injection, 

692 kde=kde, prior=prior, weights=weights 

693 ) 

694 _PlotGeneration.save( 

695 fig, filename, preliminary=preliminary 

696 ) 

697 filename = os.path.join( 

698 savedir, "{}_1d_posterior_{}_combined.png".format(label, parameter) 

699 ) 

700 if os.path.isfile(filename) and checkpoint: 

701 pass 

702 else: 

703 fig = module._1d_histogram_plot( 

704 parameter, Array(np.concatenate(same_samples)), latex_label, 

705 inj_value=injection, kde=kde, prior=prior, weights=weights 

706 ) 

707 _PlotGeneration.save( 

708 fig, filename, preliminary=preliminary 

709 ) 

710 

711 def sample_evolution_plot(self, label): 

712 """Generate sample evolution plots for all parameters in the result file 

713 

714 Parameters 

715 ---------- 

716 label: str 

717 the label for the results file that you wish to plot 

718 """ 

719 error_message = ( 

720 "Failed to generate a sample evolution plot for %s because {}" 

721 ) 

722 iterator, samples, function = self._mcmc_iterator( 

723 label, "_sample_evolution_plot" 

724 ) 

725 arguments = [ 

726 ( 

727 [ 

728 self.savedir, label, param, samples[param], 

729 latex_labels[param], self.injection_data[label][param], 

730 self.preliminary_pages[label], self.checkpoint 

731 ], function, error_message % (param) 

732 ) for param in iterator 

733 ] 

734 self.pool.starmap(self._try_to_make_a_plot, arguments) 

735 

736 def expert_plot(self, label): 

737 """Generate expert plots for diagnostics 

738 

739 Parameters 

740 ---------- 

741 label: str 

742 the label for the results file that you wish to plot 

743 """ 

744 error_message = ( 

745 "Failed to generate log_likelihood-%s 2d contour plot because {}" 

746 ) 

747 iterator, samples, function = self._mcmc_iterator( 

748 label, "_2d_contour_plot" 

749 ) 

750 _debug = self.samples[label].debug_keys() 

751 arguments = [ 

752 ( 

753 [ 

754 self.savedir, label, param, "log_likelihood", samples[param], 

755 samples["log_likelihood"], latex_labels[param], 

756 latex_labels["log_likelihood"], 

757 self.preliminary_pages[label], [ 

758 samples[param][np.argmax(samples["log_likelihood"])], 

759 np.max(samples["log_likelihood"]), 

760 ], self.checkpoint 

761 ], function, error_message % (param) 

762 ) for param in iterator + _debug 

763 ] 

764 self.pool.starmap(self._try_to_make_a_plot, arguments) 

765 _reweight_keys = [ 

766 param for param in self.samples[label].debug_keys() if 

767 "_non_reweighted" in param 

768 ] 

769 if len(_reweight_keys): 

770 error_message = ( 

771 "Failed to generate %s-%s 2d contour plot because {}" 

772 ) 

773 _base_param = lambda p: p.split("_non_reweighted")[0][1:] 

774 arguments = [ 

775 ( 

776 [ 

777 self.savedir, label, _base_param(param), param, 

778 samples[_base_param(param)], samples[param], 

779 latex_labels[_base_param(param)], latex_labels[param], 

780 self.preliminary_pages[label], None, self.checkpoint 

781 ], function, error_message % (_base_param(param), param) 

782 ) for param in _reweight_keys 

783 ] 

784 self.pool.starmap(self._try_to_make_a_plot, arguments) 

785 error_message = ( 

786 "Failed to generate a histogram plot comparing %s and %s " 

787 "because {}" 

788 ) 

789 arguments = [ 

790 ( 

791 [ 

792 self.savedir, _base_param(param), { 

793 "reweighted": samples[_base_param(param)], 

794 "non-reweighted": samples[param] 

795 }, latex_labels[_base_param(param)], ['b', 'r'], 

796 [np.nan, np.nan], True, None, self.package, 

797 self.preliminary_comparison_pages, self.checkpoint, 

798 os.path.join( 

799 self.savedir, "{}_1d_posterior_{}_{}.png".format( 

800 label, _base_param(param), param 

801 ) 

802 ) 

803 ], self._oned_histogram_comparison_plot, 

804 error_message % (_base_param(param), param) 

805 ) for param in _reweight_keys 

806 ] 

807 self.pool.starmap(self._try_to_make_a_plot, arguments) 

808 

809 error_message = ( 

810 "Failed to generate log_likelihood-%s sample_evolution plot " 

811 "because {}" 

812 ) 

813 iterator, samples, function = self._mcmc_iterator( 

814 label, "_colored_sample_evolution_plot" 

815 ) 

816 arguments = [ 

817 ( 

818 [ 

819 self.savedir, label, param, "log_likelihood", samples[param], 

820 samples["log_likelihood"], latex_labels[param], 

821 latex_labels["log_likelihood"], 

822 self.preliminary_pages[label], self.checkpoint 

823 ], function, error_message % (param) 

824 ) for param in iterator 

825 ] 

826 self.pool.starmap(self._try_to_make_a_plot, arguments) 

827 error_message = ( 

828 "Failed to generate bootstrapped oned_histogram plot for %s " 

829 "because {}" 

830 ) 

831 iterator, samples, function = self._mcmc_iterator( 

832 label, "_oned_histogram_bootstrap_plot" 

833 ) 

834 arguments = [ 

835 ( 

836 [ 

837 self.savedir, label, param, samples[param], 

838 latex_labels[param], self.preliminary_pages[label], 

839 self.package, self.checkpoint 

840 ], function, error_message % (param) 

841 ) for param in iterator 

842 ] 

843 self.pool.starmap(self._try_to_make_a_plot, arguments) 

844 

845 @staticmethod 

846 def _oned_histogram_bootstrap_plot( 

847 savedir, label, parameter, samples, latex_label, preliminary=False, 

848 package="core", checkpoint=False, nsamples=1000, ntests=100, **kwargs 

849 ): 

850 """Generate a bootstrapped oned histogram plot for a given set of 

851 samples 

852 

853 Parameters 

854 ----------