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 ".format(tmpdir) 

596 ) 

597 self.launch(command_line) 

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

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

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

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

602 np.testing.assert_almost_equal( 

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

604 ) 

605 

606 @pytest.mark.executabletest 

607 def test_strain_data(self): 

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

609 """ 

610 from pesummary.io import read 

611 from gwpy.timeseries import TimeSeries 

612 

613 H1_series = TimeSeries( 

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

615 ) 

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

617 L1_series = TimeSeries( 

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

619 ) 

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

621 command_line = ( 

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

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

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

625 ) 

626 self.launch(command_line) 

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

628 gwdata = f.gwdata 

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

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

631 for IFO in gwdata.detectors: 

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

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

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

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

636 

637 @pytest.mark.executabletest 

638 def test_gracedb(self): 

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

640 correctly stored in the meta data 

641 """ 

642 from pesummary.gw.file.read import read 

643 

644 command_line = ( 

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

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

647 ) 

648 self.launch(command_line) 

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

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

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

652 

653 @pytest.mark.executabletest 

654 def test_single(self): 

655 """Test on a single input 

656 """ 

657 command_line = ( 

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

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

660 ) 

661 self.launch(command_line) 

662 self.check_output(number=1) 

663 

664 @pytest.mark.executabletest 

665 def test_summarycombine_output(self): 

666 """Test on a summarycombine output 

667 """ 

668 from .base import make_psd, make_calibration 

669 

670 make_psd(outdir=tmpdir) 

671 make_calibration(outdir=tmpdir) 

672 command_line = ( 

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

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

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

676 ) 

677 self.launch(command_line) 

678 command_line = ( 

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

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

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

682 ) 

683 self.launch(command_line) 

684 command_line = ( 

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

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

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

688 ) 

689 self.launch(command_line) 

690 command_line = ( 

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

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

693 ) 

694 self.launch(command_line) 

695 

696 @pytest.mark.executabletest 

697 def test_mcmc(self): 

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

699 """ 

700 command_line = ( 

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

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

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

704 ) 

705 self.launch(command_line) 

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

707 

708 @pytest.mark.executabletest 

709 def test_kde_plot(self): 

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

711 """ 

712 command_line = ( 

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

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

715 "".format(tmpdir) 

716 ) 

717 self.launch(command_line) 

718 self.check_output(number=1) 

719 command_line = ( 

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

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

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

723 ) 

724 self.launch(command_line) 

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

726 

727 @pytest.mark.executabletest 

728 def test_mcmc_more_than_label(self): 

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

730 argument when multiple labels are passed. 

731 """ 

732 command_line = ( 

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

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

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

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

737 ) 

738 with pytest.raises(InputError): 

739 self.launch(command_line) 

740 

741 @pytest.mark.executabletest 

742 def test_file_format_wrong_number(self): 

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

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

745 samples 

746 """ 

747 command_line = ( 

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

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

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

751 ) 

752 with pytest.raises(InputError): 

753 self.launch(command_line) 

754 

755 @pytest.mark.executabletest 

756 def test_add_existing_plot(self): 

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

758 to the summarypages executable 

759 """ 

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

761 f.writelines("") 

762 command_line = ( 

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

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

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

766 ) 

767 self.launch(command_line) 

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

769 command_line = ( 

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

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

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

773 "".format(tmpdir) 

774 ) 

775 self.launch(command_line) 

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

777 

778 

779class TestSummaryPagesLW(Base): 

780 """Test the `summarypageslw` executable 

781 """ 

782 def setup_method(self): 

783 """Setup the SummaryPagesLW class 

784 """ 

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

786 os.mkdir(tmpdir) 

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

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

789 

790 def teardown_method(self): 

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

792 """ 

793 if os.path.isdir(tmpdir): 

794 shutil.rmtree(tmpdir) 

795 

796 def check_output( 

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

798 extra_gw_plots=True 

799 ): 

800 """Check the output from the summarypages executable 

801 """ 

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

803 plots = get_list_of_plots( 

804 gw=gw, number=number, mcmc=False, existing_plot=False, 

805 expert=False, parameters=parameters, outdir=outdir,