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 testing_dir 

13) 

14import pytest 

15from pesummary.utils.exceptions import InputError 

16import importlib 

17import tempfile 

18from pathlib import Path 

19 

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

21 

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

23 

24 

25class Base(object): 

26 """Base class for testing the executables 

27 """ 

28 def launch(self, command_line): 

29 """ 

30 """ 

31 args = command_line.split(" ") 

32 executable = args[0] 

33 cla = args[1:] 

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

35 print(cla) 

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

37 

38 

39class TestSummaryVersion(Base): 

40 """Test the `summaryversion` executable 

41 """ 

42 @pytest.mark.executabletest 

43 def test_summaryversion(self): 

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

45 """ 

46 from pesummary import __version__ 

47 import io 

48 from contextlib import redirect_stdout 

49 

50 f = io.StringIO() 

51 with redirect_stdout(f): 

52 self.launch("summaryversion") 

53 out = f.getvalue() 

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

55 

56 

57class TestSummaryGracedb(Base): 

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

59 """ 

60 def setup_method(self): 

61 """Setup the SummaryPublication class 

62 """ 

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

64 os.mkdir(tmpdir) 

65 

66 def teardown_method(self): 

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

68 """ 

69 if os.path.isdir(tmpdir): 

70 shutil.rmtree(tmpdir) 

71 

72 @pytest.mark.executabletest 

73 def test_fake_event(self): 

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

75 """ 

76 from ligo.gracedb import exceptions 

77 command_line = "summarygracedb --id S111111m" 

78 with pytest.raises(exceptions.HTTPError): 

79 self.launch(command_line) 

80 

81 @pytest.mark.executabletest 

82 def test_output(self): 

83 """Test the output from summarygracedb 

84 """ 

85 import json 

86 command_line = ( 

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

88 ) 

89 self.launch(command_line) 

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

91 data = json.load(f) 

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

93 assert "em_type" in data.keys() 

94 command_line = ( 

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

96 "--info superevent_id far created" 

97 ) 

98 self.launch(command_line) 

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

100 data2 = json.load(f) 

101 assert len(data2) == 3 

102 assert all( 

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

104 ) 

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

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

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

108 

109 

110class TestSummaryDetchar(Base): 

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

112 """ 

113 def setup_method(self): 

114 """Setup the SummaryDetchar class 

115 """ 

116 from gwpy.timeseries import TimeSeries 

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

118 os.mkdir(tmpdir) 

119 

120 H1_series = TimeSeries( 

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

122 ) 

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

124 L1_series = TimeSeries( 

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

126 ) 

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

128 

129 def teardown_method(self): 

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

131 """ 

132 if os.path.isdir(tmpdir): 

133 shutil.rmtree(tmpdir) 

134 

135 @pytest.mark.executabletest 

136 def test_spectrogram(self): 

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

138 executable 

139 """ 

140 from gwpy.timeseries import TimeSeries 

141 from matplotlib import rcParams 

142 

143 rcParams["text.usetex"] = False 

144 command_line = ( 

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

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

147 ) 

148 self.launch(command_line) 

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

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

151 

152 @pytest.mark.executabletest 

153 def test_omegascan(self): 

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

155 executable 

156 """ 

157 from gwpy.timeseries import TimeSeries 

158 command_line = ( 

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

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

161 ) 

162 self.launch(command_line) 

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

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

165 

166 

167class TestSummaryPublication(Base): 

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

169 """ 

170 def setup_method(self): 

171 """Setup the SummaryPublication class 

172 """ 

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

174 os.mkdir(tmpdir) 

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

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

177 

178 def teardown_method(self): 

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

180 """ 

181 if os.path.isdir(tmpdir): 

182 shutil.rmtree(tmpdir) 

183 

184 @pytest.mark.executabletest 

185 def test_2d_contour(self): 

186 """Test the 2d contour plot generation 

187 """ 

188 command_line = ( 

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

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

191 "--plot 2d_contour --palette colorblind" 

192 ) 

193 self.launch(command_line) 

194 assert os.path.isfile( 

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

196 ) 

197 

198 @pytest.mark.executabletest 

199 def test_violin(self): 

200 """Test the violin plot generation 

201 """ 

202 command_line = ( 

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

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

205 "--palette colorblind" 

206 ) 

207 self.launch(command_line) 

208 assert os.path.isfile( 

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

210 ) 

211 

212 @pytest.mark.executabletest 

213 def test_spin_disk(self): 

214 """Test the spin disk generation 

215 """ 

216 command_line = ( 

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

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

219 "--palette colorblind" 

220 ) 

221 self.launch(command_line) 

222 assert os.path.isfile( 

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

224 ) 

225 

226 

227class TestSummaryPipe(Base): 

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

229 """ 

230 def setup_method(self): 

231 """Setup the SummaryPipe class 

232 """ 

233 self.dirs = [ 

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

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

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

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

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

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

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

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

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

243 ] 

244 for dd in self.dirs: 

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

246 os.mkdir(dd) 

247 make_result_file( 

248 gw=False, lalinference=True, 

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

250 ) 

251 os.rename( 

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

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

254 ) 

255 make_result_file( 

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

257 ) 

258 os.rename( 

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

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

261 ) 

262 

263 def add_config_file(self): 

264 shutil.copyfile( 

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

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

267 ) 

268 shutil.copyfile( 

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

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

271 ) 

272 

273 def teardown_method(self): 

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

275 """ 

276 for dd in self.dirs: 

277 if os.path.isdir(dd): 

278 shutil.rmtree(dd) 

279 

280 @pytest.mark.executabletest 

281 def test_no_config(self): 

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

283 directory 

284 """ 

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

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

287 with pytest.raises(FileNotFoundError): 

288 self.launch(command_line) 

289 

290 @pytest.mark.executabletest 

291 def test_no_samples(self): 

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

293 directory 

294 """ 

295 self.add_config_file() 

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

297 if _type == "lalinference": 

298 os.remove( 

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

300 tmpdir, _type 

301 ) 

302 ) 

303 else: 

304 os.remove( 

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

306 ) 

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

308 with pytest.raises(FileNotFoundError): 

309 self.launch(command_line) 

310 

311 @pytest.mark.executabletest 

312 def test_basic(self): 

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

314 """ 

315 self.add_config_file() 

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

317 command_line = ( 

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

319 ) 

320 output = self.launch(command_line) 

321 assert "--config" in output 

322 print(output) 

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

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

325 assert "--samples" in output 

326 if _type == "lalinference": 

327 _f = ( 

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

329 tmpdir, _type 

330 ) 

331 ) 

332 else: 

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

334 assert _f in output 

335 assert "--webdir" in output 

336 assert "--approximant" in output 

337 assert "--labels" in output 

338 

339 @pytest.mark.executabletest 

340 def test_override(self): 

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

342 overrides the one inferred from the rundir 

343 """ 

344 self.add_config_file() 

345 command_line = ( 

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

347 ) 

348 output = self.launch(command_line) 

349 command_line += " --labels hello" 

350 output2 = self.launch(command_line) 

351 assert output != output2 

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

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

354 assert label != label2 

355 assert label2 == "hello" 

356 

357 @pytest.mark.executabletest 

358 def test_add_to_summarypages_command(self): 

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

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

361 inferred from the rundir 

362 """ 

363 self.add_config_file() 

364 command_line = ( 

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

366 ) 

367 output = self.launch(command_line) 

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

369 output2 = self.launch(command_line) 

370 assert output != output2 

371 assert "--multi_process 10" in output2 

372 assert "--cosmology Planck15_lal" in output2 

373 assert "--kde_plot" in output2 

374 assert "--multi_process 10" not in output 

375 assert "--cosmology Planck15_lal" not in output 

376 assert "--kde_plot" not in output 

377 

378 

379class TestSummaryPages(Base): 

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

381 """ 

382 def setup_method(self): 

383 """Setup the SummaryClassification class 

384 """ 

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

386 for dd in self.dirs: 

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

388 os.mkdir(dd) 

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

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

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

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

393 

394 def teardown_method(self): 

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

396 """ 

397 for dd in self.dirs: 

398 if os.path.isdir(dd): 

399 shutil.rmtree(dd) 

400 

401 def check_output( 

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

403 gw=False 

404 ): 

405 """Check the output from the summarypages executable 

406 """ 

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

408 plots = get_list_of_plots( 

409 gw=gw, number=number, mcmc=mcmc, existing_plot=existing_plot, 

410 expert=expert, outdir=tmpdir 

411 ) 

412 for i, j in zip( 

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

414 ): 

415 print(i, j) 

416 assert all( 

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

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

419 ) 

420 ) 

421 files = get_list_of_files( 

422 gw=gw, number=number, existing_plot=existing_plot, outdir=tmpdir 

423 ) 

424 assert all( 

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

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

427 ) 

428 ) 

429 

430 @pytest.mark.executabletest 

431 def test_descriptions(self): 

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

433 `--descriptions` flag is provided 

434 """ 

435 import json 

436 from pesummary.io import read 

437 command_line = ( 

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

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

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

441 ) 

442 self.launch(command_line) 

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

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

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

446 

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

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

449 command_line = ( 

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

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

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

453 ) 

454 self.launch(command_line) 

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

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

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

458 

459 @pytest.mark.executabletest 

460 def test_reweight(self): 

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

462 `--reweight_samples` flag is provided 

463 """ 

464 from pesummary.io import read 

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

466 command_line = ( 

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

468 "--labels gw0 --nsamples 100 --disable_corner " 

469 "--reweight_samples uniform_in_comoving_volume " 

470 "--pastro_category_file {1}/rates.yml " 

471 "--catch_terrestrial_probability_error".format(tmpdir, testing_dir) 

472 ) 

473 self.launch(command_line) 

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

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

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

477 reweighted = _reweighted.samples_dict 

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

479 inds = np.array([ 

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

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

482 ]) 

483 assert all( 

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

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

486 ) 

487 _kwargs = _reweighted.extra_kwargs[0] 

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

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

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

491 

492 @pytest.mark.executabletest 

493 def test_checkpoint(self): 

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

495 consistent 

496 """ 

497 import time 

498 command_line = ( 

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

500 "--labels core0 --nsamples 100 " 

501 "--restart_from_checkpoint".format(tmpdir) 

502 ) 

503 t0 = time.time() 

504 self.launch(command_line) 

505 t1 = time.time() 

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

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

508 t2 = time.time() 

509 self.launch(command_line) 

510 t3 = time.time() 

511 assert t3 - t2 < t1 - t0 

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

513 # get timestamp of plot 

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

515 assert made_time < t2 

516 

517 @pytest.mark.executabletest 

518 def test_expert(self): 

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

520 plots 

521 """ 

522 command_line = ( 

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

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

525 ) 

526 self.launch(command_line) 

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

528 command_line = ( 

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

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

531 ) 

532 self.launch(command_line) 

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

534 

535 @pytest.mark.executabletest 

536 def test_prior_input(self): 

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

538 the command line 

539 """ 

540 import importlib 

541 from bilby import gw 

542 

543 path = gw.__path__[0] 

544 bilby_prior_file = os.path.join( 

545 path, "prior_files", "GW150914.prior" 

546 ) 

547 

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

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

550 module = importlib.import_module( 

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

552 ) 

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

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

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

556 command_line = ( 

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

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

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

560 ) 

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

562 self.launch(command_line) 

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

564 if _file != bilby_prior_file: 

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

566 f = module.read(_file) 

567 original = f.samples_dict 

568 for param in original.keys(): 

569 np.testing.assert_almost_equal( 

570 original[param], stored[param] 

571 ) 

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

573 # samples as posterior samples 

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

575 else: 

576 from bilby.core.prior import PriorDict 

577 

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

579 bilby_prior = PriorDict(filename=bilby_prior_file) 

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

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

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

583 # A bilby prior file will have 10 prior samples 

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

585 

586 @pytest.mark.executabletest 

587 def test_calibration_and_psd(self): 

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

589 """ 

590 from pesummary.gw.file.read import read 

591 from .base import make_psd, make_calibration 

592 

593 make_psd(outdir=tmpdir) 

594 make_calibration(outdir=tmpdir) 

595 command_line = ( 

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

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

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

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

600 ) 

601 self.launch(command_line) 

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

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

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

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

606 np.testing.assert_almost_equal( 

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

608 ) 

609 

610 @pytest.mark.executabletest 

611 def test_strain_data(self): 

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

613 """ 

614 from pesummary.io import read 

615 from gwpy.timeseries import TimeSeries 

616 

617 H1_series = TimeSeries( 

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

619 ) 

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

621 L1_series = TimeSeries( 

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

623 ) 

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

625 command_line = ( 

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

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

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

629 ) 

630 self.launch(command_line) 

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

632 gwdata = f.gwdata 

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

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

635 for IFO in gwdata.detectors: 

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

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

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

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

640 

641 @pytest.mark.executabletest 

642 def test_gracedb(self): 

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

644 correctly stored in the meta data 

645 """ 

646 from pesummary.gw.file.read import read 

647 

648 command_line = ( 

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

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

651 ) 

652 self.launch(command_line) 

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

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

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

656 

657 @pytest.mark.executabletest 

658 def test_single(self): 

659 """Test on a single input 

660 """ 

661 command_line = ( 

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

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

664 ) 

665 self.launch(command_line) 

666 self.check_output(number=1) 

667 

668 @pytest.mark.executabletest 

669 def test_summarycombine_output(self): 

670 """Test on a summarycombine output 

671 """ 

672 from .base import make_psd, make_calibration 

673 

674 make_psd(outdir=tmpdir) 

675 make_calibration(outdir=tmpdir) 

676 command_line = ( 

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

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

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

680 ) 

681 self.launch(command_line) 

682 command_line = ( 

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

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

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

686 ) 

687 self.launch(command_line) 

688 command_line = ( 

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

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

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

692 ) 

693 self.launch(command_line) 

694 command_line = ( 

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

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

697 ) 

698 self.launch(command_line) 

699 

700 @pytest.mark.executabletest 

701 def test_mcmc(self): 

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

703 """ 

704 command_line = ( 

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

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

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

708 ) 

709 self.launch(command_line) 

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

711 

712 @pytest.mark.executabletest 

713 def test_kde_plot(self): 

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

715 """ 

716 command_line = ( 

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

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

719 "".format(tmpdir) 

720 ) 

721 self.launch(command_line) 

722 self.check_output(number=1) 

723 command_line = ( 

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

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

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

727 ) 

728 self.launch(command_line) 

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

730 

731 @pytest.mark.executabletest 

732 def test_mcmc_more_than_label(self): 

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

734 argument when multiple labels are passed. 

735 """ 

736 command_line = ( 

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

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

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

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

741 ) 

742 with pytest.raises(InputError): 

743 self.launch(command_line) 

744 

745 @pytest.mark.executabletest 

746 def test_file_format_wrong_number(self): 

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

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

749 samples 

750 """ 

751 command_line = ( 

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

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

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

755 ) 

756 with pytest.raises(InputError): 

757 self.launch(command_line) 

758 

759 @pytest.mark.executabletest 

760 def test_add_existing_plot(self): 

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

762 to the summarypages executable 

763 """ 

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

765 f.writelines("") 

766 command_line = ( 

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

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

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

770 ) 

771 self.launch(command_line) 

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

773 command_line = ( 

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

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

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

777 "".format(tmpdir) 

778 ) 

779 self.launch(command_line) 

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

781 

782 

783class TestSummaryPagesLW(Base): 

784 """Test the `summarypageslw` executable 

785 """ 

786 def setup_method(self): 

787 """Setup the SummaryPagesLW class 

788 """ 

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

790 os.mkdir(tmpdir) 

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

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

793 

794 def teardown_method(self): 

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

796 """ 

797 if os.path.isdir(tmpdir): 

798 shutil.rmtree(tmpdir) 

799 

800 def check_output( 

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

802 extra_gw_plots=True 

803 ): 

804 """Check the output from the summarypages executable 

805 """ 

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

807 plots = get_list_of_plots( 

808 gw=gw, number=number, mcmc=False, existing_plot=False,