Coverage for pesummary/tests/executable_test.py: 98.7%

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

2 

3import os 

4import shutil 

5import glob 

6import subprocess 

7from getpass import getuser 

8import numpy as np 

9 

10from .base import ( 

11 make_result_file, get_list_of_plots, get_list_of_files, data_dir 

12) 

13import pytest 

14from pesummary.utils.exceptions import InputError 

15import importlib 

16import tempfile 

17from pathlib import Path 

18 

19tmpdir = Path(tempfile.TemporaryDirectory(prefix=".", dir=".").name).name 

20 

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

22 

23 

24class Base(object): 

25 """Base class for testing the executables 

26 """ 

27 def launch(self, command_line): 

28 """ 

29 """ 

30 args = command_line.split(" ") 

31 executable = args[0] 

32 cla = args[1:] 

33 module = importlib.import_module("pesummary.cli.{}".format(executable)) 

34 print(cla) 

35 return module.main(args=[i for i in cla if i != " " and i != ""]) 

36 

37 

38class TestSummaryVersion(Base): 

39 """Test the `summaryversion` executable 

40 """ 

41 @pytest.mark.executabletest 

42 def test_summaryversion(self): 

43 """Test the `summaryversion` output matches pesummary.__version__ 

44 """ 

45 from pesummary import __version__ 

46 import io 

47 from contextlib import redirect_stdout 

48 

49 f = io.StringIO() 

50 with redirect_stdout(f): 

51 self.launch("summaryversion") 

52 out = f.getvalue() 

53 assert out.split("\n")[1] == __version__ 

54 

55 

56class TestSummaryGracedb(Base): 

57 """Test the `summarygracedb` executable with trivial examples 

58 """ 

59 def setup_method(self): 

60 """Setup the SummaryPublication class 

61 """ 

62 if not os.path.isdir(tmpdir): 

63 os.mkdir(tmpdir) 

64 

65 def teardown_method(self): 

66 """Remove the files and directories created from this class 

67 """ 

68 if os.path.isdir(tmpdir): 

69 shutil.rmtree(tmpdir) 

70 

71 @pytest.mark.executabletest 

72 def test_fake_event(self): 

73 """Test that `summarygracedb` fails when a fake event is provided 

74 """ 

75 from ligo.gracedb import exceptions 

76 command_line = "summarygracedb --id S111111m" 

77 with pytest.raises(exceptions.HTTPError): 

78 self.launch(command_line) 

79 

80 @pytest.mark.executabletest 

81 def test_output(self): 

82 """Test the output from summarygracedb 

83 """ 

84 import json 

85 command_line = ( 

86 f"summarygracedb --id S190412m --output {tmpdir}/output.json" 

87 ) 

88 self.launch(command_line) 

89 with open(f"{tmpdir}/output.json", "r") as f: 

90 data = json.load(f) 

91 assert data["superevent_id"] == "S190412m" 

92 assert "em_type" in data.keys() 

93 command_line = ( 

94 f"summarygracedb --id S190412m --output {tmpdir}/output2.json " 

95 "--info superevent_id far created" 

96 ) 

97 self.launch(command_line) 

98 with open(f"{tmpdir}/output2.json", "r") as f: 

99 data2 = json.load(f) 

100 assert len(data2) == 3 

101 assert all( 

102 info in data2.keys() for info in ["superevent_id", "far", "created"] 

103 ) 

104 assert data2["superevent_id"] == data["superevent_id"] 

105 assert data2["far"] == data["far"] 

106 assert data2["created"] == data["created"] 

107 

108 

109class TestSummaryDetchar(Base): 

110 """Test the `summarydetchar` executable with trivial examples 

111 """ 

112 def setup_method(self): 

113 """Setup the SummaryDetchar class 

114 """ 

115 from gwpy.timeseries import TimeSeries 

116 if not os.path.isdir(tmpdir): 

117 os.mkdir(tmpdir) 

118 

119 H1_series = TimeSeries( 

120 np.random.uniform(-1, 1, 1000), t0=101, dt=0.1, name="H1:test" 

121 ) 

122 H1_series.write(f"{tmpdir}/H1.gwf", format="gwf") 

123 L1_series = TimeSeries( 

124 np.random.uniform(-1, 1, 1000), t0=101, dt=0.1, name="L1:test" 

125 ) 

126 L1_series.write(f"{tmpdir}/L1.hdf", format="hdf5") 

127 

128 def teardown_method(self): 

129 """Remove the files and directories created from this class 

130 """ 

131 if os.path.isdir(tmpdir): 

132 shutil.rmtree(tmpdir) 

133 

134 @pytest.mark.executabletest 

135 def test_spectrogram(self): 

136 """Check that a spectrogram can be generated from the `summarydetchar` 

137 executable 

138 """ 

139 from gwpy.timeseries import TimeSeries 

140 from matplotlib import rcParams 

141 

142 rcParams["text.usetex"] = False 

143 command_line = ( 

144 f"summarydetchar --gwdata H1:test:{tmpdir}/H1.gwf L1:test:{tmpdir}/L1.hdf " 

145 f"--webdir {tmpdir} --plot spectrogram" 

146 ) 

147 self.launch(command_line) 

148 assert os.path.isfile(f"{tmpdir}/spectrogram_H1.png") 

149 assert os.path.isfile(f"{tmpdir}/spectrogram_L1.png") 

150 

151 @pytest.mark.executabletest 

152 def test_omegascan(self): 

153 """Check that an omegascan can be generated from the `summarydetchar` 

154 executable 

155 """ 

156 from gwpy.timeseries import TimeSeries 

157 command_line = ( 

158 f"summarydetchar --gwdata H1:test:{tmpdir}/H1.gwf L1:test:{tmpdir}/L1.hdf " 

159 f"--webdir {tmpdir} --plot omegascan --gps 150 --window 0.1" 

160 ) 

161 self.launch(command_line) 

162 assert os.path.isfile(f"{tmpdir}/omegascan_H1.png") 

163 assert os.path.isfile(f"{tmpdir}/omegascan_L1.png") 

164 

165 

166class TestSummaryPublication(Base): 

167 """Test the `summarypublication` executable with trivial examples 

168 """ 

169 def setup_method(self): 

170 """Setup the SummaryPublication class 

171 """ 

172 if not os.path.isdir(tmpdir): 

173 os.mkdir(tmpdir) 

174 make_result_file(bilby=True, gw=True, outdir=tmpdir) 

175 os.rename(f"{tmpdir}/test.json", f"{tmpdir}/bilby.json") 

176 

177 def teardown_method(self): 

178 """Remove the files and directories created from this class 

179 """ 

180 if os.path.isdir(tmpdir): 

181 shutil.rmtree(tmpdir) 

182 

183 @pytest.mark.executabletest 

184 def test_2d_contour(self): 

185 """Test the 2d contour plot generation 

186 """ 

187 command_line = ( 

188 f"summarypublication --webdir {tmpdir} --samples {tmpdir}/bilby.json " 

189 "--labels test --parameters mass_1 mass_2 --levels 0.9 0.5 " 

190 "--plot 2d_contour --palette colorblind" 

191 ) 

192 self.launch(command_line) 

193 assert os.path.isfile( 

194 os.path.join(tmpdir, "2d_contour_plot_mass_1_and_mass_2.png") 

195 ) 

196 

197 @pytest.mark.executabletest 

198 def test_violin(self): 

199 """Test the violin plot generation 

200 """ 

201 command_line = ( 

202 f"summarypublication --webdir {tmpdir} --samples {tmpdir}/bilby.json " 

203 "--labels test --parameters mass_1 --plot violin " 

204 "--palette colorblind" 

205 ) 

206 self.launch(command_line) 

207 assert os.path.isfile( 

208 os.path.join(tmpdir, "violin_plot_mass_1.png") 

209 ) 

210 

211 @pytest.mark.executabletest 

212 def test_spin_disk(self): 

213 """Test the spin disk generation 

214 """ 

215 command_line = ( 

216 f"summarypublication --webdir {tmpdir} --samples {tmpdir}/bilby.json " 

217 "--labels test --parameters mass_1 --plot spin_disk " 

218 "--palette colorblind" 

219 ) 

220 self.launch(command_line) 

221 assert os.path.isfile( 

222 os.path.join(tmpdir, "spin_disk_plot_test.png") 

223 ) 

224 

225 

226class TestSummaryPipe(Base): 

227 """Test the `summarypipe` executable with trivial examples 

228 """ 

229 def setup_method(self): 

230 """Setup the SummaryPipe class 

231 """ 

232 self.dirs = [ 

233 tmpdir, "{}/lalinference".format(tmpdir), "{}/bilby".format(tmpdir), 

234 "{}/lalinference/posterior_samples".format(tmpdir), 

235 "{}/lalinference/ROQdata".format(tmpdir), 

236 "{}/lalinference/engine".format(tmpdir), 

237 "{}/lalinference/caches".format(tmpdir), 

238 "{}/lalinference/log".format(tmpdir), 

239 "{}/bilby/data".format(tmpdir), "{}/bilby/result".format(tmpdir), 

240 "{}/bilby/submit".format(tmpdir), 

241 "{}/bilby/log_data_analysis".format(tmpdir) 

242 ] 

243 for dd in self.dirs: 

244 if not os.path.isdir(dd): 

245 os.mkdir(dd) 

246 make_result_file( 

247 gw=False, lalinference=True, 

248 outdir="{}/lalinference/posterior_samples/".format(tmpdir) 

249 ) 

250 os.rename( 

251 "{}/lalinference/posterior_samples/test.hdf5".format(tmpdir), 

252 "{}/lalinference/posterior_samples/posterior_HL_result.hdf5".format(tmpdir) 

253 ) 

254 make_result_file( 

255 gw=False, bilby=True, outdir="{}/bilby/result/".format(tmpdir) 

256 ) 

257 os.rename( 

258 "{}/bilby/result/test.json".format(tmpdir), 

259 "{}/bilby/result/label_result.json".format(tmpdir) 

260 ) 

261 

262 def add_config_file(self): 

263 shutil.copyfile( 

264 os.path.join(data_dir, "config_lalinference.ini"), 

265 "{}/lalinference/config.ini".format(tmpdir) 

266 ) 

267 shutil.copyfile( 

268 os.path.join(data_dir, "config_bilby.ini"), 

269 "{}/bilby/config.ini".format(tmpdir) 

270 ) 

271 

272 def teardown_method(self): 

273 """Remove the files and directories created from this class 

274 """ 

275 for dd in self.dirs: 

276 if os.path.isdir(dd): 

277 shutil.rmtree(dd) 

278 

279 @pytest.mark.executabletest 

280 def test_no_config(self): 

281 """Test that the code fails if there is no config file in the 

282 directory 

283 """ 

284 for _type in ["lalinference", "bilby"]: 

285 command_line = "summarypipe --rundir {}/{}".format(tmpdir, _type) 

286 with pytest.raises(FileNotFoundError): 

287 self.launch(command_line) 

288 

289 @pytest.mark.executabletest 

290 def test_no_samples(self): 

291 """Test that the code fails if there are no posterior samples in the 

292 directory 

293 """ 

294 self.add_config_file() 

295 for _type in ["lalinference", "bilby"]: 

296 if _type == "lalinference": 

297 os.remove( 

298 "{}/{}/posterior_samples/posterior_HL_result.hdf5".format( 

299 tmpdir, _type 

300 ) 

301 ) 

302 else: 

303 os.remove( 

304 "{}/{}/result/label_result.json".format(tmpdir, _type) 

305 ) 

306 command_line = "summarypipe --rundir {}/{}".format(tmpdir, _type) 

307 with pytest.raises(FileNotFoundError): 

308 self.launch(command_line) 

309 

310 @pytest.mark.executabletest 

311 def test_basic(self): 

312 """Test that the code runs for a trivial example 

313 """ 

314 self.add_config_file() 

315 for _type in ["lalinference", "bilby"]: 

316 command_line = ( 

317 "summarypipe --rundir {}/{} --return_string".format(tmpdir, _type) 

318 ) 

319 output = self.launch(command_line) 

320 assert "--config" in output 

321 print(output) 

322 print("{}/{}/config.ini".format(tmpdir, _type)) 

323 assert "{}/{}/config.ini".format(tmpdir, _type) in output 

324 assert "--samples" in output 

325 if _type == "lalinference": 

326 _f = ( 

327 "{}/{}/posterior_samples/posterior_HL_result.hdf5".format( 

328 tmpdir, _type 

329 ) 

330 ) 

331 else: 

332 _f = "{}/{}/result/label_result.json".format(tmpdir, _type) 

333 assert _f in output 

334 assert "--webdir" in output 

335 assert "--approximant" in output 

336 assert "--labels" in output 

337 

338 @pytest.mark.executabletest 

339 def test_override(self): 

340 """Test that when you provide an option from the command line it 

341 overrides the one inferred from the rundir 

342 """ 

343 self.add_config_file() 

344 command_line = ( 

345 "summarypipe --rundir {}/lalinference --return_string".format(tmpdir) 

346 ) 

347 output = self.launch(command_line) 

348 command_line += " --labels hello" 

349 output2 = self.launch(command_line) 

350 assert output != output2 

351 label = output.split(" ")[output.split(" ").index("--labels") + 1] 

352 label2 = output2.split(" ")[output2.split(" ").index("--labels") + 1] 

353 assert label != label2 

354 assert label2 == "hello" 

355 

356 @pytest.mark.executabletest 

357 def test_add_to_summarypages_command(self): 

358 """Test that when you provide an option from the command line that 

359 is not already in the summarypages command line, it adds it to the one 

360 inferred from the rundir 

361 """ 

362 self.add_config_file() 

363 command_line = ( 

364 "summarypipe --rundir {}/lalinference --return_string".format(tmpdir) 

365 ) 

366 output = self.launch(command_line) 

367 command_line += " --multi_process 10 --kde_plot --cosmology Planck15_lal" 

368 output2 = self.launch(command_line) 

369 assert output != output2 

370 assert "--multi_process 10" in output2 

371 assert "--cosmology Planck15_lal" in output2 

372 assert "--kde_plot" in output2 

373 assert "--multi_process 10" not in output 

374 assert "--cosmology Planck15_lal" not in output 

375 assert "--kde_plot" not in output 

376 

377 

378class TestSummaryPages(Base): 

379 """Test the `summarypages` executable with trivial examples 

380 """ 

381 def setup_method(self): 

382 """Setup the SummaryClassification class 

383 """ 

384 self.dirs = [tmpdir, "{}1".format(tmpdir), "{}2".format(tmpdir)] 

385 for dd in self.dirs: 

386 if not os.path.isdir(dd): 

387 os.mkdir(dd) 

388 make_result_file(outdir=tmpdir, gw=False, extension="json") 

389 os.rename("{}/test.json".format(tmpdir), "{}/example.json".format(tmpdir)) 

390 make_result_file(outdir=tmpdir, gw=False, extension="hdf5") 

391 os.rename("{}/test.h5".format(tmpdir), "{}/example2.h5".format(tmpdir)) 

392 

393 def teardown_method(self): 

394 """Remove the files and directories created from this class 

395 """ 

396 for dd in self.dirs: 

397 if os.path.isdir(dd): 

398 shutil.rmtree(dd) 

399 

400 def check_output( 

401 self, number=1, mcmc=False, existing_plot=False, expert=False, 

402 gw=False 

403 ): 

404 """Check the output from the summarypages executable 

405 """ 

406 assert os.path.isfile("{}/home.html".format(tmpdir)) 

407 plots = get_list_of_plots( 

408 gw=gw, number=number, mcmc=mcmc, existing_plot=existing_plot, 

409 expert=expert, outdir=tmpdir 

410 ) 

411 for i, j in zip( 

412 sorted(plots), sorted(glob.glob("{}/plots/*.png".format(tmpdir))) 

413 ): 

414 print(i, j) 

415 assert all( 

416 i == j for i, j in zip( 

417 sorted(plots), sorted(glob.glob("{}/plots/*.png".format(tmpdir))) 

418 ) 

419 ) 

420 files = get_list_of_files( 

421 gw=gw, number=number, existing_plot=existing_plot, outdir=tmpdir 

422 ) 

423 assert all( 

424 i == j for i, j in zip( 

425 sorted(files), sorted(glob.glob("{}/html/*.html".format(tmpdir))) 

426 ) 

427 ) 

428 

429 @pytest.mark.executabletest 

430 def test_descriptions(self): 

431 """Check that summarypages stores the correct descriptions when the 

432 `--descriptions` flag is provided 

433 """ 

434 import json 

435 from pesummary.io import read 

436 command_line = ( 

437 "summarypages --webdir {0} --samples {0}/example.json " 

438 "{0}/example.json --labels core0 core1 --nsamples 100 " 

439 "--disable_corner --descriptions core0:Description".format(tmpdir) 

440 ) 

441 self.launch(command_line) 

442 opened = read("{}/samples/posterior_samples.h5".format(tmpdir)) 

443 assert opened.description["core0"] == "Description" 

444 assert opened.description["core1"] == "No description found" 

445 

446 with open("{}/descriptions.json".format(tmpdir), "w") as f: 

447 json.dump({"core0": "Testing description", "core1": "Test"}, f) 

448 command_line = ( 

449 "summarypages --webdir {0} --samples {0}/example.json " 

450 "{0}/example.json --labels core0 core1 --nsamples 100 " 

451 "--disable_corner --descriptions {0}/descriptions.json".format(tmpdir) 

452 ) 

453 self.launch(command_line) 

454 opened = read("{}/samples/posterior_samples.h5".format(tmpdir)) 

455 assert opened.description["core0"] == "Testing description" 

456 assert opened.description["core1"] == "Test" 

457 

458 @pytest.mark.executabletest 

459 def test_reweight(self): 

460 """Check that summarypages reweights the posterior samples if the 

461 `--reweight_samples` flag is provided 

462 """ 

463 from pesummary.io import read 

464 make_result_file(gw=True, extension="json", outdir=tmpdir) 

465 command_line = ( 

466 "summarypages --webdir {0} --samples {0}/test.json --gw " 

467 "--labels gw0 --nsamples 100 --disable_corner " 

468 "--reweight_samples uniform_in_comoving_volume ".format(tmpdir) 

469 ) 

470 self.launch(command_line) 

471 self.check_output(number=1, expert=False, gw=True) 

472 original = read("{0}/test.json".format(tmpdir)).samples_dict 

473 _reweighted = read("{0}/samples/posterior_samples.h5".format(tmpdir)) 

474 reweighted = _reweighted.samples_dict 

475 assert original.number_of_samples >= reweighted["gw0"].number_of_samples 

476 inds = np.array([ 

477 original.parameters.index(param) for param in 

478 reweighted["gw0"].parameters if param in original.parameters 

479 ]) 

480 assert all( 

481 reweighted_sample[inds] in original.samples.T for reweighted_sample 

482 in reweighted["gw0"].samples.T 

483 ) 

484 _kwargs = _reweighted.extra_kwargs[0] 

485 assert _kwargs["sampler"]["nsamples_before_reweighting"] == 100 

486 assert _kwargs["sampler"]["nsamples"] == reweighted["gw0"].number_of_samples 

487 assert _kwargs["meta_data"]["reweighting"] == "uniform_in_comoving_volume" 

488 

489 @pytest.mark.executabletest 

490 def test_checkpoint(self): 

491 """Check that when restarting from checkpoint, the outputs are 

492 consistent 

493 """ 

494 import time 

495 command_line = ( 

496 "summarypages --webdir {0} --samples {0}/example.json " 

497 "--labels core0 --nsamples 100 " 

498 "--restart_from_checkpoint".format(tmpdir) 

499 ) 

500 t0 = time.time() 

501 self.launch(command_line) 

502 t1 = time.time() 

503 assert os.path.isfile("{}/checkpoint/pesummary_resume.pickle".format(tmpdir)) 

504 self.check_output(number=1, expert=False) 

505 t2 = time.time() 

506 self.launch(command_line) 

507 t3 = time.time() 

508 assert t3 - t2 < t1 - t0 

509 self.check_output(number=1, expert=False) 

510 # get timestamp of plot 

511 made_time = os.path.getmtime(glob.glob("{}/plots/*.png".format(tmpdir))[0]) 

512 assert made_time < t2 

513 

514 @pytest.mark.executabletest 

515 def test_expert(self): 

516 """Check that summarypages produces the expected expert diagnostic 

517 plots 

518 """ 

519 command_line = ( 

520 "summarypages --webdir {0} --samples {0}/example.json " 

521 "--labels core0 --nsamples 100".format(tmpdir) 

522 ) 

523 self.launch(command_line) 

524 self.check_output(number=1, expert=False) 

525 command_line = ( 

526 "summarypages --webdir {0} --samples {0}/example.json " 

527 "--labels core0 --nsamples 100 --enable_expert".format(tmpdir) 

528 ) 

529 self.launch(command_line) 

530 self.check_output(number=1, expert=True) 

531 

532 @pytest.mark.executabletest 

533 def test_prior_input(self): 

534 """Check that `summarypages` works when a prior file is passed from 

535 the command line 

536 """ 

537 import importlib 

538 from bilby import gw 

539 

540 path = gw.__path__[0] 

541 bilby_prior_file = os.path.join( 

542 path, "prior_files", "GW150914.prior" 

543 ) 

544 

545 for package in ["core", "gw"]: 

546 gw = True if package == "gw" else False 

547 module = importlib.import_module( 

548 "pesummary.{}.file.read".format(package) 

549 ) 

550 make_result_file(outdir=tmpdir, gw=gw, extension="json") 

551 os.rename("{}/test.json".format(tmpdir), "{}/prior.json".format(tmpdir)) 

552 for _file in ["{}/prior.json".format(tmpdir), bilby_prior_file]: 

553 command_line = ( 

554 "summarypages --webdir {} --samples {}/example.json " 

555 "--labels test --prior_file {} --nsamples_for_prior " 

556 "10 ".format(tmpdir, tmpdir, _file) 

557 ) 

558 command_line += " --gw" if gw else "" 

559 self.launch(command_line) 

560 f = module.read("{}/samples/posterior_samples.h5".format(tmpdir)) 

561 if _file != bilby_prior_file: 

562 stored = f.priors["samples"]["test"] 

563 f = module.read(_file) 

564 original = f.samples_dict 

565 for param in original.keys(): 

566 np.testing.assert_almost_equal( 

567 original[param], stored[param] 

568 ) 

569 # Non-bilby prior file will have same number or prior 

570 # samples as posterior samples 

571 assert len(stored[param]) == 1000 

572 else: 

573 from bilby.core.prior import PriorDict 

574 

575 analytic = f.priors["analytic"]["test"] 

576 bilby_prior = PriorDict(filename=bilby_prior_file) 

577 for param, value in bilby_prior.items(): 

578 assert analytic[param] == str(value) 

579 params = list(f.priors["samples"]["test"].keys()) 

580 # A bilby prior file will have 10 prior samples 

581 assert len(f.priors["samples"]["test"][params[0]]) == 10 

582 

583 @pytest.mark.executabletest 

584 def test_calibration_and_psd(self): 

585 """Test that the calibration and psd files are passed appropiately 

586 """ 

587 from pesummary.gw.file.read import read 

588 from .base import make_psd, make_calibration 

589 

590 make_psd(outdir=tmpdir) 

591 make_calibration(outdir=tmpdir) 

592 command_line = ( 

593 "summarypages --webdir {0} --samples {0}/example.json " 

594 "--psd H1:{0}/psd.dat --calibration L1:{0}/calibration.dat " 

595 "--labels test --posterior_samples_filename example.h5 " 

596 "--calibration_definition template".format(tmpdir) 

597 ) 

598 self.launch(command_line) 

599 f = read("{}/samples/example.h5".format(tmpdir)) 

600 psd = np.genfromtxt("{}/psd.dat".format(tmpdir)) 

601 calibration = np.genfromtxt("{}/calibration.dat".format(tmpdir)) 

602 np.testing.assert_almost_equal(f.psd["test"]["H1"], psd) 

603 np.testing.assert_almost_equal( 

604 f.priors["calibration"]["test"]["L1"], calibration 

605 ) 

606 

607 @pytest.mark.executabletest 

608 def test_strain_data(self): 

609 """Test that the gravitational wave data is passed appropiately 

610 """ 

611 from pesummary.io import read 

612 from gwpy.timeseries import TimeSeries 

613 

614 H1_series = TimeSeries( 

615 np.random.uniform(-1, 1, 1000), t0=101, dt=0.1, name="H1:test" 

616 ) 

617 H1_series.write("{}/H1.gwf".format(tmpdir), format="gwf") 

618 L1_series = TimeSeries( 

619 np.random.uniform(-1, 1, 1000), t0=201, dt=0.2, name="L1:test" 

620 ) 

621 L1_series.write("{}/L1.hdf".format(tmpdir), format="hdf5") 

622 command_line = ( 

623 "summarypages --webdir {0} --samples {0}/example.json " 

624 "--gwdata H1:test:{0}/H1.gwf L1:test:{0}/L1.hdf " 

625 "--labels test --disable_corner --disable_interactive".format(tmpdir) 

626 ) 

627 self.launch(command_line) 

628 f = read("{}/samples/posterior_samples.h5".format(tmpdir)) 

629 gwdata = f.gwdata 

630 assert all(IFO in gwdata.detectors for IFO in ["H1", "L1"]) 

631 strain = {"H1": H1_series, "L1": L1_series} 

632 for IFO in gwdata.detectors: 

633 np.testing.assert_almost_equal(gwdata[IFO].value, strain[IFO].value) 

634 assert gwdata[IFO].t0 == strain[IFO].t0 

635 assert gwdata[IFO].dt == strain[IFO].dt 

636 assert gwdata[IFO].unit == strain[IFO].unit 

637 

638 @pytest.mark.executabletest 

639 def test_gracedb(self): 

640 """Test that when the gracedb ID is passed from the command line it is 

641 correctly stored in the meta data 

642 """ 

643 from pesummary.gw.file.read import read 

644 

645 command_line = ( 

646 "summarypages --webdir {0} --samples {0}/example.json " 

647 "--gracedb G17864 --gw --labels test".format(tmpdir) 

648 ) 

649 self.launch(command_line) 

650 f = read("{}/samples/posterior_samples.h5".format(tmpdir)) 

651 assert "gracedb" in f.extra_kwargs[0]["meta_data"] 

652 assert "G17864" == f.extra_kwargs[0]["meta_data"]["gracedb"]["id"] 

653 

654 @pytest.mark.executabletest 

655 def test_single(self): 

656 """Test on a single input 

657 """ 

658 command_line = ( 

659 "summarypages --webdir {0} --samples " 

660 "{0}/example.json --label core0 ".format(tmpdir) 

661 ) 

662 self.launch(command_line) 

663 self.check_output(number=1) 

664 

665 @pytest.mark.executabletest 

666 def test_summarycombine_output(self): 

667 """Test on a summarycombine output 

668 """ 

669 from .base import make_psd, make_calibration 

670 

671 make_psd(outdir=tmpdir) 

672 make_calibration(outdir=tmpdir) 

673 command_line = ( 

674 "summarycombine --webdir {0}1 --samples " 

675 "{0}/example.json --label gw0 " 

676 "--calibration L1:{0}/calibration.dat --gw".format(tmpdir) 

677 ) 

678 self.launch(command_line) 

679 command_line = ( 

680 "summarycombine --webdir {0}2 --samples " 

681 "{0}/example.json --label gw1 " 

682 "--psd H1:{0}/psd.dat --gw".format(tmpdir) 

683 ) 

684 self.launch(command_line) 

685 command_line = ( 

686 "summarycombine --webdir {0} --gw --samples " 

687 "{0}1/samples/posterior_samples.h5 " 

688 "{0}2/samples/posterior_samples.h5 ".format(tmpdir) 

689 ) 

690 self.launch(command_line) 

691 command_line = ( 

692 "summarypages --webdir {0} --gw --samples " 

693 "{0}/samples/posterior_samples.h5 ".format(tmpdir) 

694 ) 

695 self.launch(command_line) 

696 

697 @pytest.mark.executabletest 

698 def test_mcmc(self): 

699 """Test the `--mcmc_samples` command line argument 

700 """ 

701 command_line = ( 

702 "summarypages --webdir {0} --samples " 

703 "{0}/example.json {0}/example2.h5 " 

704 "--label core0 --mcmc_samples".format(tmpdir) 

705 ) 

706 self.launch(command_line) 

707 self.check_output(number=1, mcmc=True) 

708 

709 @pytest.mark.executabletest 

710 def test_kde_plot(self): 

711 """Test that the kde plots work on a single input and on MCMC inputs 

712 """ 

713 command_line = ( 

714 "summarypages --webdir {0} --samples " 

715 "{0}/example.json --label core0 --kde_plot " 

716 "".format(tmpdir) 

717 ) 

718 self.launch(command_line) 

719 self.check_output(number=1) 

720 command_line = ( 

721 "summarypages --webdir {0} --samples " 

722 "{0}/example.json {0}/example2.h5 " 

723 "--label core0 --mcmc_samples --kde_plot".format(tmpdir) 

724 ) 

725 self.launch(command_line) 

726 self.check_output(number=1, mcmc=True) 

727 

728 @pytest.mark.executabletest 

729 def test_mcmc_more_than_label(self): 

730 """Test that the code fails with the `--mcmc_samples` command line 

731 argument when multiple labels are passed. 

732 """ 

733 command_line = ( 

734 "summarypages --webdir {0} --samples " 

735 "{0}/example.json {0}/example2.h5 " 

736 "{0}/example.json {0}/example2.h5 " 

737 "--label core0 core1 --mcmc_samples".format(tmpdir) 

738 ) 

739 with pytest.raises(InputError): 

740 self.launch(command_line) 

741 

742 @pytest.mark.executabletest 

743 def test_file_format_wrong_number(self): 

744 """Test that the code fails with the `--file_format` command line 

745 argument when the number of file formats does not match the number of 

746 samples 

747 """ 

748 command_line = ( 

749 "summarypages --webdir {0} --samples " 

750 "{0}/example.json {0}/example2.h5 " 

751 "--file_format hdf5 json dat".format(tmpdir) 

752 ) 

753 with pytest.raises(InputError): 

754 self.launch(command_line) 

755 

756 @pytest.mark.executabletest 

757 def test_add_existing_plot(self): 

758 """Test that an Additional page is made if existing plots are provided 

759 to the summarypages executable 

760 """ 

761 with open("{}/test.png".format(tmpdir), "w") as f: 

762 f.writelines("") 

763 command_line = ( 

764 "summarypages --webdir {0} --samples " 

765 "{0}/example.json --label core0 --add_existing_plot " 

766 "core0:{0}/test.png ".format(tmpdir) 

767 ) 

768 self.launch(command_line) 

769 self.check_output(number=1, existing_plot=True) 

770 command_line = ( 

771 "summarypages --webdir {0} --samples " 

772 "{0}/example.json {0}/example.json --label core0 core1 " 

773 "--add_existing_plot core0:{0}/test.png core1:{0}/test.png " 

774 "".format(tmpdir) 

775 ) 

776 self.launch(command_line) 

777 self.check_output(number=2, existing_plot=True) 

778 

779 

780class TestSummaryPagesLW(Base): 

781 """Test the `summarypageslw` executable 

782 """ 

783 def setup_method(self): 

784 """Setup the SummaryPagesLW class 

785 """ 

786 if not os.path.isdir(tmpdir): 

787 os.mkdir(tmpdir) 

788 make_result_file(bilby=True, gw=True, outdir=tmpdir) 

789 os.rename("{}/test.json".format(tmpdir), "{}/bilby.json".format(tmpdir)) 

790 

791 def teardown_method(self): 

792 """Remove the files and directories created from this class 

793 """ 

794 if os.path.isdir(tmpdir): 

795 shutil.rmtree(tmpdir) 

796 

797 def check_output( 

798 self, gw=False, number=1, outdir=tmpdir, parameters=[], sections=[], 

799 extra_gw_plots=True 

800 ): 

801 """Check the output from the summarypages executable 

802 """ 

803 assert os.path.isfile("./{}/home.html".format(outdir)) 

804 plots = get_list_of_plots( 

805 gw=gw, number=number, mcmc=False, existing_plot=False, 

806 expert=False, parameters=parameters, outdir=outdir,