Coverage for pesummary/gw/cli/inputs.py: 78.7%

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

2 

3import ast 

4import os 

5import numpy as np 

6import pesummary.core.cli.inputs 

7from pesummary.gw.file.read import read as GWRead 

8from pesummary.gw.file.psd import PSD 

9from pesummary.gw.file.calibration import Calibration 

10from pesummary.utils.decorators import deprecation 

11from pesummary.utils.exceptions import InputError 

12from pesummary.utils.utils import logger 

13from pesummary import conf 

14 

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

16 

17 

18class _GWInput(pesummary.core.cli.inputs._Input): 

19 """Super class to handle gw specific command line inputs 

20 """ 

21 @staticmethod 

22 def grab_data_from_metafile( 

23 existing_file, webdir, compare=None, nsamples=None, **kwargs 

24 ): 

25 """Grab data from an existing PESummary metafile 

26 

27 Parameters 

28 ---------- 

29 existing_file: str 

30 path to the existing metafile 

31 webdir: str 

32 the directory to store the existing configuration file 

33 compare: list, optional 

34 list of labels for events stored in an existing metafile that you 

35 wish to compare 

36 """ 

37 _replace_kwargs = { 

38 "psd": "{file}.psd['{label}']" 

39 } 

40 if "psd_default" in kwargs.keys(): 

41 _replace_kwargs["psd_default"] = kwargs["psd_default"] 

42 data = pesummary.core.cli.inputs._Input.grab_data_from_metafile( 

43 existing_file, webdir, compare=compare, read_function=GWRead, 

44 nsamples=nsamples, _replace_with_pesummary_kwargs=_replace_kwargs, 

45 **kwargs 

46 ) 

47 f = GWRead(existing_file) 

48 

49 labels = data["labels"] 

50 

51 psd = {i: {} for i in labels} 

52 if f.psd is not None and f.psd != {}: 

53 for i in labels: 

54 if i in f.psd.keys() and f.psd[i] != {}: 

55 psd[i] = { 

56 ifo: PSD(f.psd[i][ifo]) for ifo in f.psd[i].keys() 

57 } 

58 calibration = {i: {} for i in labels} 

59 if f.calibration is not None and f.calibration != {}: 

60 for i in labels: 

61 if i in f.calibration.keys() and f.calibration[i] != {}: 

62 calibration[i] = { 

63 ifo: Calibration(f.calibration[i][ifo]) for ifo in 

64 f.calibration[i].keys() 

65 } 

66 skymap = {i: None for i in labels} 

67 if hasattr(f, "skymap") and f.skymap is not None and f.skymap != {}: 

68 for i in labels: 

69 if i in f.skymap.keys() and len(f.skymap[i]): 

70 skymap[i] = f.skymap[i] 

71 data.update( 

72 { 

73 "approximant": { 

74 i: j for i, j in zip( 

75 labels, [f.approximant[ind] for ind in data["indicies"]] 

76 ) 

77 }, 

78 "psd": psd, 

79 "calibration": calibration, 

80 "skymap": skymap 

81 } 

82 ) 

83 return data 

84 

85 @property 

86 def grab_data_kwargs(self): 

87 kwargs = super(_GWInput, self).grab_data_kwargs 

88 for _property in ["f_start", "f_low", "f_ref", "f_final", "delta_f"]: 

89 if getattr(self, _property) is None: 

90 setattr(self, "_{}".format(_property), [None] * len(self.labels)) 

91 elif len(getattr(self, _property)) == 1 and len(self.labels) != 1: 

92 setattr( 

93 self, "_{}".format(_property), 

94 getattr(self, _property) * len(self.labels) 

95 ) 

96 if self.opts.approximant is None: 

97 approx = [None] * len(self.labels) 

98 else: 

99 approx = self.opts.approximant 

100 self.approximant_flags = self.opts.approximant_flags 

101 resume_file = [ 

102 os.path.join( 

103 self.webdir, "checkpoint", 

104 "{}_conversion_class.pickle".format(label) 

105 ) for label in self.labels 

106 ] 

107 

108 try: 

109 for num, label in enumerate(self.labels): 

110 try: 

111 psd = self.psd[label] 

112 except KeyError: 

113 psd = {} 

114 kwargs[label].update(dict( 

115 evolve_spins_forwards=self.evolve_spins_forwards, 

116 evolve_spins_backwards=self.evolve_spins_backwards, 

117 f_start=self.f_start[num], f_low=self.f_low[num], 

118 approximant_flags=self.approximant_flags.get(label, {}), 

119 approximant=approx[num], f_ref=self.f_ref[num], 

120 NRSur_fits=self.NRSur_fits, return_kwargs=True, 

121 multipole_snr=self.calculate_multipole_snr, 

122 precessing_snr=self.calculate_precessing_snr, 

123 psd=psd, f_final=self.f_final[num], 

124 waveform_fits=self.waveform_fits, 

125 multi_process=self.opts.multi_process, 

126 redshift_method=self.redshift_method, 

127 cosmology=self.cosmology, 

128 no_conversion=self.no_conversion, 

129 add_zero_spin=True, delta_f=self.delta_f[num], 

130 psd_default=self.psd_default, 

131 disable_remnant=self.disable_remnant, 

132 force_BBH_remnant_computation=self.force_BBH_remnant_computation, 

133 resume_file=resume_file[num], 

134 restart_from_checkpoint=self.restart_from_checkpoint, 

135 force_BH_spin_evolution=self.force_BH_spin_evolution, 

136 )) 

137 return kwargs 

138 except IndexError: 

139 logger.warning( 

140 "Unable to find an f_ref, f_low and approximant for each " 

141 "label. Using and f_ref={}, f_low={} and approximant={} " 

142 "for all result files".format( 

143 self.f_ref[0], self.f_low[0], approx[0] 

144 ) 

145 ) 

146 for num, label in enumerate(self.labels): 

147 kwargs[label].update(dict( 

148 evolve_spins_forwards=self.evolve_spins_forwards, 

149 evolve_spins_backwards=self.evolve_spins_backwards, 

150 f_start=self.f_start[0], f_low=self.f_low[0], 

151 approximant=approx[0], f_ref=self.f_ref[0], 

152 NRSur_fits=self.NRSur_fits, return_kwargs=True, 

153 multipole_snr=self.calculate_multipole_snr, 

154 precessing_snr=self.calculate_precessing_snr, 

155 psd=self.psd[self.labels[0]], f_final=self.f_final[0], 

156 waveform_fits=self.waveform_fits, 

157 multi_process=self.opts.multi_process, 

158 redshift_method=self.redshift_method, 

159 cosmology=self.cosmology, 

160 no_conversion=self.no_conversion, 

161 add_zero_spin=True, delta_f=self.delta_f[0], 

162 psd_default=self.psd_default, 

163 disable_remnant=self.disable_remnant, 

164 force_BBH_remnant_computation=self.force_BBH_remnant_computation, 

165 resume_file=resume_file[num], 

166 restart_from_checkpoint=self.restart_from_checkpoint, 

167 force_BH_spin_evolution=self.force_BH_spin_evolution 

168 )) 

169 return kwargs 

170 

171 @staticmethod 

172 def grab_data_from_file( 

173 file, label, webdir, config=None, injection=None, file_format=None, 

174 nsamples=None, disable_prior_sampling=False, **kwargs 

175 ): 

176 """Grab data from a result file containing posterior samples 

177 

178 Parameters 

179 ---------- 

180 file: str 

181 path to the result file 

182 label: str 

183 label that you wish to use for the result file 

184 config: str, optional 

185 path to a configuration file used in the analysis 

186 injection: str, optional 

187 path to an injection file used in the analysis 

188 file_format, str, optional 

189 the file format you wish to use when loading. Default None. 

190 If None, the read function loops through all possible options 

191 """ 

192 data = pesummary.core.cli.inputs._Input.grab_data_from_file( 

193 file, label, webdir, config=config, injection=injection, 

194 read_function=GWRead, file_format=file_format, nsamples=nsamples, 

195 disable_prior_sampling=disable_prior_sampling, **kwargs 

196 ) 

197 try: 

198 for _kwgs in data["file_kwargs"][label]: 

199 if "approximant_flags" in _kwgs["meta_data"]: 

200 for key, item in _kwargs["meta_data"]["approximant_flags"].items(): 

201 warning_cond = ( 

202 key in self.approximant_flags[label] and 

203 self.approximant_flags[label][key] != item 

204 ) 

205 if warning_cond: 

206 logger.warning( 

207 "Approximant flag {}={} found in result file for {}. " 

208 "Ignoring and using the provided values {}={}".format( 

209 key, self.approximant_flags[label][key], label, 

210 key, item 

211 ) 

212 ) 

213 else: 

214 self.approximant_flags[label][key] = item 

215 except Exception: 

216 pass 

217 return data 

218 

219 @property 

220 def reweight_samples(self): 

221 return self._reweight_samples 

222 

223 @reweight_samples.setter 

224 def reweight_samples(self, reweight_samples): 

225 from pesummary.gw.reweight import options 

226 self._reweight_samples = self._check_reweight_samples( 

227 reweight_samples, options 

228 ) 

229 

230 def _set_samples(self, *args, **kwargs): 

231 super(_GWInput, self)._set_samples(*args, **kwargs) 

232 if "calibration" not in self.priors: 

233 self.priors["calibration"] = { 

234 label: {} for label in self.labels 

235 } 

236 

237 def _set_corner_params(self, corner_params): 

238 corner_params = super(_GWInput, self)._set_corner_params(corner_params) 

239 if corner_params is None: 

240 logger.debug( 

241 "Using the default corner parameters: {}".format( 

242 ", ".join(conf.gw_corner_parameters) 

243 ) 

244 ) 

245 else: 

246 _corner_params = corner_params 

247 corner_params = list(set(conf.gw_corner_parameters + corner_params)) 

248 for param in _corner_params: 

249 _data = self.samples 

250 if not all(param in _data[label].keys() for label in self.labels): 

251 corner_params.remove(param) 

252 logger.debug( 

253 "Generating a corner plot with the following " 

254 "parameters: {}".format(", ".join(corner_params)) 

255 ) 

256 return corner_params 

257 

258 @property 

259 def cosmology(self): 

260 return self._cosmology 

261 

262 @cosmology.setter 

263 def cosmology(self, cosmology): 

264 from pesummary.gw.cosmology import available_cosmologies 

265 

266 if cosmology.lower() not in available_cosmologies: 

267 logger.warning( 

268 "Unrecognised cosmology: {}. Using {} as default".format( 

269 cosmology, conf.cosmology 

270 ) 

271 ) 

272 cosmology = conf.cosmology 

273 else: 

274 logger.debug("Using the {} cosmology".format(cosmology)) 

275 self._cosmology = cosmology 

276 

277 @property 

278 def approximant(self): 

279 return self._approximant 

280 

281 @approximant.setter 

282 def approximant(self, approximant): 

283 if not hasattr(self, "_approximant"): 

284 approximant_list = {i: {} for i in self.labels} 

285 if approximant is None: 

286 logger.warning( 

287 "No approximant passed. Waveform plots will not be " 

288 "generated" 

289 ) 

290 elif approximant is not None: 

291 if len(approximant) != len(self.labels): 

292 raise InputError( 

293 "Please pass an approximant for each result file" 

294 ) 

295 approximant_list = { 

296 i: j for i, j in zip(self.labels, approximant) 

297 } 

298 self._approximant = approximant_list 

299 else: 

300 for num, i in enumerate(self._approximant.keys()): 

301 if self._approximant[i] == {}: 

302 if num == 0: 

303 logger.warning( 

304 "No approximant passed. Waveform plots will not be " 

305 "generated" 

306 ) 

307 self._approximant[i] = None 

308 break 

309 

310 @property 

311 def approximant_flags(self): 

312 return self._approximant_flags 

313 

314 @approximant_flags.setter 

315 def approximant_flags(self, approximant_flags): 

316 if hasattr(self, "_approximant_flags"): 

317 return 

318 _approximant_flags = {key: {} for key in self.labels} 

319 for key, item in approximant_flags.items(): 

320 _label, key = key.split(":") 

321 if _label not in self.labels: 

322 raise ValueError( 

323 "Unable to assign waveform flags for label:{} because " 

324 "it does not exist. Available labels are: {}. Approximant " 

325 "flags must be provided in the form LABEL:FLAG:VALUE".format( 

326 _label, ", ".join(self.labels) 

327 ) 

328 ) 

329 _approximant_flags[_label][key] = item 

330 self._approximant_flags = _approximant_flags 

331 

332 @property 

333 def gracedb_server(self): 

334 return self._gracedb_server 

335 

336 @gracedb_server.setter 

337 def gracedb_server(self, gracedb_server): 

338 if gracedb_server is None: 

339 self._gracedb_server = conf.gracedb_server 

340 else: 

341 logger.debug( 

342 "Using '{}' as the GraceDB server".format(gracedb_server) 

343 ) 

344 self._gracedb_server = gracedb_server 

345 

346 @property 

347 def gracedb(self): 

348 return self._gracedb 

349 

350 @gracedb.setter 

351 def gracedb(self, gracedb): 

352 self._gracedb = gracedb 

353 if gracedb is not None: 

354 from pesummary.gw.gracedb import get_gracedb_data, HTTPError 

355 from json.decoder import JSONDecodeError 

356 

357 first_letter = gracedb[0] 

358 if first_letter != "G" and first_letter != "g" and first_letter != "S": 

359 logger.warning( 

360 "Invalid GraceDB ID passed. The GraceDB ID must be of the " 

361 "form G0000 or S0000. Ignoring input." 

362 ) 

363 self._gracedb = None 

364 return 

365 _error = ( 

366 "Unable to download data from Gracedb because {}. Only storing " 

367 "the GraceDB ID in the metafile" 

368 ) 

369 try: 

370 logger.info( 

371 "Downloading {} from gracedb for {}".format( 

372 ", ".join(self.gracedb_data), gracedb 

373 ) 

374 ) 

375 json = get_gracedb_data( 

376 gracedb, info=self.gracedb_data, 

377 service_url=self.gracedb_server 

378 ) 

379 json["id"] = gracedb 

380 except (HTTPError, RuntimeError, JSONDecodeError) as e: 

381 logger.warning(_error.format(e)) 

382 json = {"id": gracedb} 

383 

384 for label in self.labels: 

385 self.file_kwargs[label]["meta_data"]["gracedb"] = json 

386 

387 @property 

388 def detectors(self): 

389 return self._detectors 

390 

391 @detectors.setter 

392 def detectors(self, detectors): 

393 detector = {} 

394 if not detectors: 

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

396 params = list(self.samples[i].keys()) 

397 individual_detectors = [] 

398 for j in params: 

399 if "optimal_snr" in j and j != "network_optimal_snr": 

400 det = j.split("_optimal_snr")[0] 

401 individual_detectors.append(det) 

402 individual_detectors = sorted( 

403 [str(i) for i in individual_detectors]) 

404 if individual_detectors: 

405 detector[i] = "_".join(individual_detectors) 

406 else: 

407 detector[i] = None 

408 else: 

409 detector = detectors 

410 logger.debug("The detector network is %s" % (detector)) 

411 self._detectors = detector 

412 

413 @property 

414 def skymap(self): 

415 return self._skymap 

416 

417 @skymap.setter 

418 def skymap(self, skymap): 

419 if not hasattr(self, "_skymap"): 

420 self._skymap = {i: None for i in self.labels} 

421 

422 @property 

423 def calibration_definition(self): 

424 return self._calibration_definition 

425 

426 @calibration_definition.setter 

427 def calibration_definition(self, calibration_definition): 

428 if not len(self.opts.calibration): 

429 self._calibration_definition = None 

430 return 

431 if len(calibration_definition) == 1: 

432 logger.info( 

433 f"Assuming that the calibration correction was applied to " 

434 f"'{calibration_definition[0]}' for all analyses" 

435 ) 

436 calibration_definition *= len(self.labels) 

437 elif len(calibration_definition) != len(self.labels): 

438 raise ValueError( 

439 f"Please provide a calibration definition for each analysis " 

440 f"({len(self.labels)}) or a single definition to use for all " 

441 f"analyses" 

442 ) 

443 if any(_ not in ["data", "template"] for _ in calibration_definition): 

444 raise ValueError( 

445 "Calibration definitions must be either 'data' or 'template'" 

446 ) 

447 self._calibration_definition = { 

448 label: calibration_definition[num] for num, label in 

449 enumerate(self.labels) 

450 } 

451 

452 @property 

453 def calibration(self): 

454 return self._calibration 

455 

456 @calibration.setter 

457 def calibration(self, calibration): 

458 if not hasattr(self, "_calibration"): 

459 data = {i: {} for i in self.labels} 

460 if calibration != {}: 

461 prior_data = self.get_psd_or_calibration_data( 

462 calibration, self.extract_calibration_data_from_file, 

463 type=self.calibration_definition[self.labels[0]] 

464 ) 

465 self.add_to_prior_dict("calibration", prior_data) 

466 else: 

467 prior_data = {i: {} for i in self.labels} 

468 for label in self.labels: 

469 if hasattr(self.opts, "{}_calibration".format(label)): 

470 cal_data = getattr(self.opts, "{}_calibration".format(label)) 

471 if cal_data != {} and cal_data is not None: 

472 prior_data[label] = { 

473 ifo: self.extract_calibration_data_from_file( 

474 cal_data[ifo], type=self.calibration_definition[label] 

475 ) for ifo in cal_data.keys() 

476 } 

477 if not all(prior_data[i] == {} for i in self.labels): 

478 self.add_to_prior_dict("calibration", prior_data) 

479 else: 

480 self.add_to_prior_dict("calibration", {}) 

481 for num, i in enumerate(self.result_files): 

482 _opened = self._open_result_files 

483 if i in _opened.keys() and _opened[i] is not None: 

484 f = self._open_result_files[i] 

485 else: 

486 f = GWRead(i, disable_prior=True) 

487 try: 

488 calibration_data = f.interpolate_calibration_spline_posterior() 

489 except Exception as e: 

490 logger.warning( 

491 "Failed to extract calibration data from the result " 

492 "file: {} because {}".format(i, e) 

493 ) 

494 calibration_data = None 

495 labels = list(self.samples.keys()) 

496 if calibration_data is None: 

497 data[labels[num]] = { 

498 None: None 

499 } 

500 elif isinstance(f, pesummary.gw.file.formats.pesummary.PESummary): 

501 for num in range(len(calibration_data[0])): 

502 data[labels[num]] = { 

503 j: k for j, k in zip( 

504 calibration_data[1][num], 

505 calibration_data[0][num] 

506 ) 

507 } 

508 else: 

509 data[labels[num]] = { 

510 j: k for j, k in zip( 

511 calibration_data[1], calibration_data[0] 

512 ) 

513 } 

514 self._calibration = data 

515 

516 @property 

517 def psd(self): 

518 return self._psd 

519 

520 @psd.setter 

521 def psd(self, psd): 

522 if not hasattr(self, "_psd"): 

523 data = {i: {} for i in self.labels} 

524 if psd != {}: 

525 data = self.get_psd_or_calibration_data( 

526 psd, self.extract_psd_data_from_file 

527 ) 

528 else: 

529 for label in self.labels: 

530 if hasattr(self.opts, "{}_psd".format(label)): 

531 psd_data = getattr(self.opts, "{}_psd".format(label)) 

532 if psd_data != {} and psd_data is not None: 

533 data[label] = { 

534 ifo: self.extract_psd_data_from_file( 

535 psd_data[ifo], IFO=ifo 

536 ) for ifo in psd_data.keys() 

537 } 

538 self._psd = data 

539 

540 @property 

541 def nsamples_for_skymap(self): 

542 return self._nsamples_for_skymap 

543 

544 @nsamples_for_skymap.setter 

545 def nsamples_for_skymap(self, nsamples_for_skymap): 

546 self._nsamples_for_skymap = nsamples_for_skymap 

547 if nsamples_for_skymap is not None: 

548 self._nsamples_for_skymap = int(nsamples_for_skymap) 

549 number_of_samples = [ 

550 data.number_of_samples for label, data in self.samples.items() 

551 ] 

552 if not all(i > self._nsamples_for_skymap for i in number_of_samples): 

553 min_arg = np.argmin(number_of_samples) 

554 logger.warning( 

555 "You have specified that you would like to use {} " 

556 "samples to generate the skymap but the file {} only " 

557 "has {} samples. Reducing the number of samples to " 

558 "generate the skymap to {}".format( 

559 self._nsamples_for_skymap, self.result_files[min_arg], 

560 number_of_samples[min_arg], number_of_samples[min_arg] 

561 ) 

562 ) 

563 self._nsamples_for_skymap = int(number_of_samples[min_arg]) 

564 

565 @property 

566 def gwdata(self): 

567 return self._gwdata 

568 

569 @gwdata.setter 

570 def gwdata(self, gwdata): 

571 from pesummary.gw.file.strain import StrainDataDict 

572 

573 self._gwdata = gwdata 

574 if gwdata is not None: 

575 if isinstance(gwdata, dict): 

576 for i in gwdata.keys(): 

577 if not os.path.isfile(gwdata[i]): 

578 raise InputError( 

579 "The file {} does not exist. Please check the path " 

580 "to your strain file".format(gwdata[i]) 

581 ) 

582 self._gwdata = StrainDataDict.read(gwdata) 

583 else: 

584 logger.warning( 

585 "Please provide gwdata as a dictionary with keys " 

586 "displaying the channel and item giving the path to the " 

587 "strain file" 

588 ) 

589 self._gwdata = None 

590 

591 @property 

592 def evolve_spins_forwards(self): 

593 return self._evolve_spins_forwards 

594 

595 @evolve_spins_forwards.setter 

596 def evolve_spins_forwards(self, evolve_spins_forwards): 

597 self._evolve_spins_forwards = evolve_spins_forwards 

598 _msg = "Spins will be evolved up to {}" 

599 if evolve_spins_forwards: 

600 logger.info(_msg.format("Schwarzschild ISCO frequency")) 

601 self._evolve_spins_forwards = 6. ** -0.5 

602 

603 @property 

604 def evolve_spins_backwards(self): 

605 return self._evolve_spins_backwards 

606 

607 @evolve_spins_backwards.setter 

608 def evolve_spins_backwards(self, evolve_spins_backwards): 

609 self._evolve_spins_backwards = evolve_spins_backwards 

610 _msg = ( 

611 "Spins will be evolved backwards to an infinite separation using the '{}' " 

612 "method" 

613 ) 

614 if isinstance(evolve_spins_backwards, (str, bytes)): 

615 logger.info(_msg.format(evolve_spins_backwards)) 

616 elif evolve_spins_backwards is None: 

617 logger.info(_msg.format("precession_averaged")) 

618 self._evolve_spins_backwards = "precession_averaged" 

619 

620 @property 

621 def NRSur_fits(self): 

622 return self._NRSur_fits 

623 

624 @NRSur_fits.setter 

625 def NRSur_fits(self, NRSur_fits): 

626 self._NRSur_fits = NRSur_fits 

627 base = ( 

628 "Using the '{}' NRSurrogate model to calculate the remnant " 

629 "quantities" 

630 ) 

631 if isinstance(NRSur_fits, (str, bytes)): 

632 logger.info(base.format(NRSur_fits)) 

633 self._NRSur_fits = NRSur_fits 

634 elif NRSur_fits is None: 

635 from pesummary.gw.conversions.nrutils import NRSUR_MODEL 

636 

637 logger.info(base.format(NRSUR_MODEL)) 

638 self._NRSur_fits = NRSUR_MODEL 

639 

640 @property 

641 def waveform_fits(self): 

642 return self._waveform_fits 

643 

644 @waveform_fits.setter 

645 def waveform_fits(self, waveform_fits): 

646 self._waveform_fits = waveform_fits 

647 if waveform_fits: 

648 logger.info( 

649 "Evaluating the remnant quantities using the provided " 

650 "approximant" 

651 ) 

652 

653 @property 

654 def f_low(self): 

655 return self._f_low 

656 

657 @f_low.setter 

658 def f_low(self, f_low): 

659 self._f_low = f_low 

660 if f_low is not None: 

661 self._f_low = [float(i) for i in f_low] 

662 

663 @property 

664 def f_start(self): 

665 return self._f_start 

666 

667 @f_start.setter 

668 def f_start(self, f_start): 

669 self._f_start = f_start 

670 if f_start is not None: 

671 self._f_start = [float(i) for i in f_start] 

672 

673 @property 

674 def f_ref(self): 

675 return self._f_ref 

676 

677 @f_ref.setter 

678 def f_ref(self, f_ref): 

679 self._f_ref = f_ref 

680 if f_ref is not None: 

681 self._f_ref = [float(i) for i in f_ref] 

682 

683 @property 

684 def f_final(self): 

685 return self._f_final 

686 

687 @f_final.setter 

688 def f_final(self, f_final): 

689 self._f_final = f_final 

690 if f_final is not None: 

691 self._f_final = [float(i) for i in f_final] 

692 

693 @property 

694 def delta_f(self): 

695 return self._delta_f 

696 

697 @delta_f.setter 

698 def delta_f(self, delta_f): 

699 self._delta_f = delta_f 

700 if delta_f is not None: 

701 self._delta_f = [float(i) for i in delta_f] 

702 

703 @property 

704 def psd_default(self): 

705 return self._psd_default 

706 

707 @psd_default.setter 

708 def psd_default(self, psd_default): 

709 self._psd_default = psd_default 

710 if "stored:" in psd_default: 

711 label = psd_default.split("stored:")[1] 

712 self._psd_default = "{file}.psd['%s']" % (label) 

713 return 

714 try: 

715 from pycbc import psd 

716 psd_default = getattr(psd, psd_default) 

717 except ImportError: 

718 logger.warning( 

719 "Unable to import 'pycbc'. Unable to generate a default PSD" 

720 ) 

721 psd_default = None 

722 except AttributeError: 

723 logger.warning( 

724 "'pycbc' does not have the '{}' psd available. Using '{}' as " 

725 "the default PSD".format(psd_default, conf.psd) 

726 ) 

727 psd_default = getattr(psd, conf.psd) 

728 except ValueError as e: 

729 logger.warning("Setting 'psd_default' to None because {}".format(e)) 

730 psd_default = None 

731 self._psd_default = psd_default 

732 

733 @property 

734 def pepredicates_probs(self): 

735 return self._pepredicates_probs 

736 

737 @pepredicates_probs.setter 

738 def pepredicates_probs(self, pepredicates_probs): 

739 from pesummary.gw.classification import PEPredicates 

740 

741 classifications = {} 

742 for num, i in enumerate(list(self.samples.keys())): 

743 try: 

744 classifications[i] = PEPredicates( 

745 self.samples[i] 

746 ).dual_classification() 

747 except Exception as e: 

748 logger.warning( 

749 "Failed to generate source classification probabilities " 

750 "because {}".format(e) 

751 ) 

752 classifications[i] = None 

753 if self.mcmc_samples: 

754 if any(_probs is None for _probs in classifications.values()): 

755 classifications[self.labels[0]] = None 

756 logger.warning( 

757 "Unable to average classification probabilities across " 

758 "mcmc chains because one or more chains failed to estimate " 

759 "classifications" 

760 ) 

761 else: 

762 logger.debug( 

763 "Averaging classification probability across mcmc samples" 

764 ) 

765 classifications[self.labels[0]] = { 

766 prior: { 

767 key: np.round(np.mean( 

768 [val[prior][key] for val in classifications.values()] 

769 ), 3) for key in _probs.keys()