diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index afb3a5cbb4c6be452a01f304d30808ffc639548a..e9a72a2c56d4d62655f4a4c0d1510e0426f18a40 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -157,3 +157,18 @@ deploy_release:
- twine upload dist/*
only:
- tags
+
+
+precommits-py3.7:
+ stage: test
+ image: bilbydev/v2-dockerfile-test-suite-python37
+ script:
+ - source activate python37
+ - mkdir -p .pip37
+ - pip install --upgrade pip
+ - pip --cache-dir=.pip37 install --upgrade bilby
+ - pip --cache-dir=.pip37 install .
+ - pip --cache-dir=.pip37 install pre-commit
+
+ # Run precommits (flake8, spellcheck, isort, no merge conflicts, etc)
+ - pre-commit run --all-files --verbose --show-diff-on-failure
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..584f8a6395f249eb1ea039ff8fff466e968b99ef
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,22 @@
+repos:
+- repo: https://github.com/pre-commit/pre-commit-hooks
+ rev: v2.3.0
+ hooks:
+ - id: check-merge-conflict # prevent committing files with merge conflicts
+ - id: flake8 # checks for flake8 errors
+#- repo: https://github.com/codespell-project/codespell
+# rev: v1.16.0
+# hooks:
+# - id: codespell # Spellchecker
+# args: [-L, nd, --skip, "*.ipynb,*.html", --ignore-words=.dictionary.txt]
+# exclude: ^examples/tutorials/
+#- repo: https://github.com/asottile/seed-isort-config
+# rev: v1.3.0
+# hooks:
+# - id: seed-isort-config
+# args: [--application-directories, 'bilby/']
+#- repo: https://github.com/pre-commit/mirrors-isort
+# rev: v4.3.21
+# hooks:
+# - id: isort # sort imports alphabetically and separates import into sections
+# args: [-w=88, -m=3, -tc, -sp=setup.cfg ]
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7f06615b5cea7b69218515d600424d1990f5ce83..fad47cfea4302f734ed66a0783471444a1edc0b8 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -49,6 +49,33 @@ def my_new_function(x, y, print=False):
5. Don't repeat yourself. If code is repeated in multiple places, wrap it up into a function.
6. Add tests. The C.I. is there to do the work of "checking" the code, both now and into the future. Use it.
+## Automated code checking
+
+In order to automate checking of the code quality, we use
+[pre-commit](https://pre-commit.com/). For more details, see the documentation,
+here we will give a quick-start guide:
+1. Install and configure:
+```console
+$ pip install pre-commit # install the pre-commit package
+$ cd bilby
+$ pre-commit install
+```
+2. Now, when you run `$ git commit`, there will be a pre-commit check.
+ This is going to search for issues in your code: spelling, formatting, etc.
+ In some cases, it will automatically fix the code, in other cases, it will
+ print a warning. If it automatically fixed the code, you'll need to add the
+ changes to the index (`$ git add FILE.py`) and run `$ git commit` again. If
+ it didn't automatically fix the code, but still failed, it will have printed
+ a message as to why the commit failed. Read the message, fix the issues,
+ then recommit.
+3. The pre-commit checks are done to avoid pushing and then failing. But, you
+ can skip them by running `$ git commit --no-verify`, but note that the C.I.
+ still does the check so you won't be able to merge until the issues are
+ resolved.
+If you experience any issues with pre-commit, please ask for support on the
+usual help channels.
+
+
## Code relevance
The bilby code base is intended to be highly modular and flexible. We encourage
diff --git a/docs/conf.py b/docs/conf.py
index 0a8f39f461a3b222c902d1cb18b48c74b2534bc0..3f7baa1e30c05be5d907b00a6c97abcb248f3597 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -173,5 +173,3 @@ texinfo_documents = [
]
numpydoc_show_class_members = False
-
-
diff --git a/setup.cfg b/setup.cfg
index ad60888c125af2650afb6c2b495a3cbf720123e0..3be0c12d81dd02e9544e2bf520941df0ccd68546 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,7 +1,7 @@
[flake8]
exclude = .git,docs,build,dist,test,*__init__.py
max-line-length = 120
-ignore = E129 W503 W504 W605 E203
+ignore = E129 W503 W504 W605 E203 E402
[tool:pytest]
addopts =
diff --git a/test/calibration_test.py b/test/calibration_test.py
index 48f0544a0e376e6be5acc1984466288f0739221b..3b0fd708bd07395f0aecffae26971a6e5c9cc8f6 100644
--- a/test/calibration_test.py
+++ b/test/calibration_test.py
@@ -4,7 +4,6 @@ import numpy as np
class TestBaseClass(unittest.TestCase):
-
def setUp(self):
self.model = calibration.Recalibrate()
@@ -12,7 +11,7 @@ class TestBaseClass(unittest.TestCase):
del self.model
def test_repr(self):
- expected = 'Recalibrate(prefix={})'.format('\'recalib_\'')
+ expected = "Recalibrate(prefix={})".format("'recalib_'")
actual = repr(self.model)
self.assertEqual(expected, actual)
@@ -23,18 +22,22 @@ class TestBaseClass(unittest.TestCase):
class TestCubicSpline(unittest.TestCase):
-
def setUp(self):
- self.prefix = 'recalib_'
+ self.prefix = "recalib_"
self.minimum_frequency = 20
self.maximum_frequency = 1024
self.n_points = 5
self.model = calibration.CubicSpline(
- prefix=self.prefix, minimum_frequency=self.minimum_frequency,
- maximum_frequency=self.maximum_frequency, n_points=self.n_points)
- self.parameters = {'recalib_{}_{}'.format(param, ii): 0.0
- for ii in range(5)
- for param in ['amplitude', 'phase']}
+ prefix=self.prefix,
+ minimum_frequency=self.minimum_frequency,
+ maximum_frequency=self.maximum_frequency,
+ n_points=self.n_points,
+ )
+ self.parameters = {
+ "recalib_{}_{}".format(param, ii): 0.0
+ for ii in range(5)
+ for param in ["amplitude", "phase"]
+ }
def tearDown(self):
del self.prefix
@@ -46,27 +49,28 @@ class TestCubicSpline(unittest.TestCase):
def test_calibration_factor(self):
frequency_array = np.linspace(20, 1024, 1000)
- cal_factor = self.model.get_calibration_factor(frequency_array,
- **self.parameters)
+ cal_factor = self.model.get_calibration_factor(
+ frequency_array, **self.parameters
+ )
assert np.alltrue(cal_factor.real == np.ones_like(frequency_array))
def test_repr(self):
- expected = 'CubicSpline(prefix=\'{}\', minimum_frequency={}, maximum_frequency={}, n_points={})'\
- .format(self.prefix, self.minimum_frequency, self.maximum_frequency, self.n_points)
+ expected = "CubicSpline(prefix='{}', minimum_frequency={}, maximum_frequency={}, n_points={})".format(
+ self.prefix, self.minimum_frequency, self.maximum_frequency, self.n_points
+ )
actual = repr(self.model)
self.assertEqual(expected, actual)
class TestCubicSplineRequiresFourNodes(unittest.TestCase):
-
def test_cannot_instantiate_with_too_few_nodes(self):
for ii in range(6):
if ii < 4:
with self.assertRaises(ValueError):
- calibration.CubicSpline('test', 1, 10, ii)
+ calibration.CubicSpline("test", 1, 10, ii)
else:
- calibration.CubicSpline('test', 1, 10, ii)
+ calibration.CubicSpline("test", 1, 10, ii)
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/context.py b/test/context.py
index 51b34ed4ebce1df271dab84d0392090fd702dcbc..ed1eb85ae53420d4f127f29b3ed05f89fdf6de0a 100644
--- a/test/context.py
+++ b/test/context.py
@@ -1,5 +1,6 @@
import os
import sys
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
-import bilby
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+import bilby # noqa
diff --git a/test/conversion_test.py b/test/conversion_test.py
index a9729099faeca2cbfac63da4ee900b7143d11987..fcd0443523d9a377e2e8e41cb68a15979b89e946 100644
--- a/test/conversion_test.py
+++ b/test/conversion_test.py
@@ -1,6 +1,5 @@
from __future__ import division, absolute_import
import unittest
-import mock
import numpy as np
@@ -9,36 +8,55 @@ from bilby.gw import conversion
class TestBasicConversions(unittest.TestCase):
-
def setUp(self):
self.mass_1 = 1.4
self.mass_2 = 1.3
- self.mass_ratio = 13/14
+ self.mass_ratio = 13 / 14
self.total_mass = 2.7
- self.chirp_mass = (1.4 * 1.3)**0.6 / 2.7**0.2
- self.symmetric_mass_ratio = (1.4 * 1.3) / 2.7**2
+ self.chirp_mass = (1.4 * 1.3) ** 0.6 / 2.7 ** 0.2
+ self.symmetric_mass_ratio = (1.4 * 1.3) / 2.7 ** 2
self.cos_angle = -1
self.angle = np.pi
self.lambda_1 = 300
- self.lambda_2 = 300 * (14 / 13)**5
- self.lambda_tilde = 8 / 13 * (
- (1 + 7 * self.symmetric_mass_ratio
- - 31 * self.symmetric_mass_ratio**2)
- * (self.lambda_1 + self.lambda_2)
- + (1 - 4 * self.symmetric_mass_ratio)**0.5
- * (1 + 9 * self.symmetric_mass_ratio
- - 11 * self.symmetric_mass_ratio**2)
- * (self.lambda_1 - self.lambda_2)
+ self.lambda_2 = 300 * (14 / 13) ** 5
+ self.lambda_tilde = (
+ 8
+ / 13
+ * (
+ (
+ 1
+ + 7 * self.symmetric_mass_ratio
+ - 31 * self.symmetric_mass_ratio ** 2
+ )
+ * (self.lambda_1 + self.lambda_2)
+ + (1 - 4 * self.symmetric_mass_ratio) ** 0.5
+ * (
+ 1
+ + 9 * self.symmetric_mass_ratio
+ - 11 * self.symmetric_mass_ratio ** 2
+ )
+ * (self.lambda_1 - self.lambda_2)
+ )
)
- self.delta_lambda_tilde = 1 / 2 * (
- (1 - 4 * self.symmetric_mass_ratio)**0.5
- * (1 - 13272 / 1319 * self.symmetric_mass_ratio
- + 8944 / 1319 * self.symmetric_mass_ratio**2)
+ self.delta_lambda_tilde = (
+ 1
+ / 2
+ * (
+ (1 - 4 * self.symmetric_mass_ratio) ** 0.5
+ * (
+ 1
+ - 13272 / 1319 * self.symmetric_mass_ratio
+ + 8944 / 1319 * self.symmetric_mass_ratio ** 2
+ )
* (self.lambda_1 + self.lambda_2)
- + (1 - 15910 / 1319 * self.symmetric_mass_ratio
- + 32850 / 1319 * self.symmetric_mass_ratio**2
- + 3380 / 1319 * self.symmetric_mass_ratio**3)
+ + (
+ 1
+ - 15910 / 1319 * self.symmetric_mass_ratio
+ + 32850 / 1319 * self.symmetric_mass_ratio ** 2
+ + 3380 / 1319 * self.symmetric_mass_ratio ** 3
+ )
* (self.lambda_1 - self.lambda_2)
+ )
)
def tearDown(self):
@@ -50,25 +68,35 @@ class TestBasicConversions(unittest.TestCase):
del self.symmetric_mass_ratio
def test_total_mass_and_mass_ratio_to_component_masses(self):
- mass_1, mass_2 = conversion.total_mass_and_mass_ratio_to_component_masses(self.mass_ratio, self.total_mass)
- self.assertTrue(all([abs(mass_1 - self.mass_1) < 1e-5,
- abs(mass_2 - self.mass_2) < 1e-5]))
+ mass_1, mass_2 = conversion.total_mass_and_mass_ratio_to_component_masses(
+ self.mass_ratio, self.total_mass
+ )
+ self.assertTrue(
+ all([abs(mass_1 - self.mass_1) < 1e-5, abs(mass_2 - self.mass_2) < 1e-5])
+ )
def test_chirp_mass_and_primary_mass_to_mass_ratio(self):
mass_ratio = conversion.chirp_mass_and_primary_mass_to_mass_ratio(
- self.chirp_mass, self.mass_1)
+ self.chirp_mass, self.mass_1
+ )
self.assertAlmostEqual(self.mass_ratio, mass_ratio)
def test_symmetric_mass_ratio_to_mass_ratio(self):
- mass_ratio = conversion.symmetric_mass_ratio_to_mass_ratio(self.symmetric_mass_ratio)
+ mass_ratio = conversion.symmetric_mass_ratio_to_mass_ratio(
+ self.symmetric_mass_ratio
+ )
self.assertAlmostEqual(self.mass_ratio, mass_ratio)
def test_chirp_mass_and_total_mass_to_symmetric_mass_ratio(self):
- symmetric_mass_ratio = conversion.chirp_mass_and_total_mass_to_symmetric_mass_ratio(self.chirp_mass, self.total_mass)
+ symmetric_mass_ratio = conversion.chirp_mass_and_total_mass_to_symmetric_mass_ratio(
+ self.chirp_mass, self.total_mass
+ )
self.assertAlmostEqual(self.symmetric_mass_ratio, symmetric_mass_ratio)
def test_chirp_mass_and_mass_ratio_to_total_mass(self):
- total_mass = conversion.chirp_mass_and_mass_ratio_to_total_mass(self.chirp_mass, self.mass_ratio)
+ total_mass = conversion.chirp_mass_and_mass_ratio_to_total_mass(
+ self.chirp_mass, self.mass_ratio
+ )
self.assertAlmostEqual(self.total_mass, total_mass)
def test_component_masses_to_chirp_mass(self):
@@ -80,7 +108,9 @@ class TestBasicConversions(unittest.TestCase):
self.assertAlmostEqual(self.total_mass, total_mass)
def test_component_masses_to_symmetric_mass_ratio(self):
- symmetric_mass_ratio = conversion.component_masses_to_symmetric_mass_ratio(self.mass_1, self.mass_2)
+ symmetric_mass_ratio = conversion.component_masses_to_symmetric_mass_ratio(
+ self.mass_1, self.mass_2
+ )
self.assertAlmostEqual(self.symmetric_mass_ratio, symmetric_mass_ratio)
def test_component_masses_to_mass_ratio(self):
@@ -88,196 +118,281 @@ class TestBasicConversions(unittest.TestCase):
self.assertAlmostEqual(self.mass_ratio, mass_ratio)
def test_mass_1_and_chirp_mass_to_mass_ratio(self):
- mass_ratio = conversion.mass_1_and_chirp_mass_to_mass_ratio(self.mass_1, self.chirp_mass)
+ mass_ratio = conversion.mass_1_and_chirp_mass_to_mass_ratio(
+ self.mass_1, self.chirp_mass
+ )
self.assertAlmostEqual(self.mass_ratio, mass_ratio)
def test_lambda_tilde_to_lambda_1_lambda_2(self):
- lambda_1, lambda_2 =\
- conversion.lambda_tilde_to_lambda_1_lambda_2(
- self.lambda_tilde, self.mass_1, self.mass_2)
- self.assertTrue(all([abs(self.lambda_1 - lambda_1) < 1e-5,
- abs(self.lambda_2 - lambda_2) < 1e-5]))
+ lambda_1, lambda_2 = conversion.lambda_tilde_to_lambda_1_lambda_2(
+ self.lambda_tilde, self.mass_1, self.mass_2
+ )
+ self.assertTrue(
+ all(
+ [
+ abs(self.lambda_1 - lambda_1) < 1e-5,
+ abs(self.lambda_2 - lambda_2) < 1e-5,
+ ]
+ )
+ )
def test_lambda_tilde_delta_lambda_tilde_to_lambda_1_lambda_2(self):
- lambda_1, lambda_2 =\
- conversion.lambda_tilde_delta_lambda_tilde_to_lambda_1_lambda_2(
- self.lambda_tilde, self.delta_lambda_tilde, self.mass_1, self.mass_2)
- self.assertTrue(all([abs(self.lambda_1 - lambda_1) < 1e-5,
- abs(self.lambda_2 - lambda_2) < 1e-5]))
+ (
+ lambda_1,
+ lambda_2,
+ ) = conversion.lambda_tilde_delta_lambda_tilde_to_lambda_1_lambda_2(
+ self.lambda_tilde, self.delta_lambda_tilde, self.mass_1, self.mass_2
+ )
+ self.assertTrue(
+ all(
+ [
+ abs(self.lambda_1 - lambda_1) < 1e-5,
+ abs(self.lambda_2 - lambda_2) < 1e-5,
+ ]
+ )
+ )
def test_lambda_1_lambda_2_to_lambda_tilde(self):
- lambda_tilde = \
- conversion.lambda_1_lambda_2_to_lambda_tilde(
- self.lambda_1, self.lambda_2, self.mass_1, self.mass_2)
+ lambda_tilde = conversion.lambda_1_lambda_2_to_lambda_tilde(
+ self.lambda_1, self.lambda_2, self.mass_1, self.mass_2
+ )
self.assertTrue((self.lambda_tilde - lambda_tilde) < 1e-5)
def test_lambda_1_lambda_2_to_delta_lambda_tilde(self):
- delta_lambda_tilde = \
- conversion.lambda_1_lambda_2_to_delta_lambda_tilde(
- self.lambda_1, self.lambda_2, self.mass_1, self.mass_2)
+ delta_lambda_tilde = conversion.lambda_1_lambda_2_to_delta_lambda_tilde(
+ self.lambda_1, self.lambda_2, self.mass_1, self.mass_2
+ )
self.assertTrue((self.delta_lambda_tilde - delta_lambda_tilde) < 1e-5)
class TestConvertToLALParams(unittest.TestCase):
-
def setUp(self):
self.search_keys = []
self.parameters = dict()
self.component_mass_pars = dict(mass_1=1.4, mass_2=1.4)
self.mass_parameters = self.component_mass_pars.copy()
- self.mass_parameters['mass_ratio'] =\
- conversion.component_masses_to_mass_ratio(**self.component_mass_pars)
- self.mass_parameters['symmetric_mass_ratio'] = \
- conversion.component_masses_to_symmetric_mass_ratio(**self.component_mass_pars)
- self.mass_parameters['chirp_mass'] = \
- conversion.component_masses_to_chirp_mass(**self.component_mass_pars)
- self.mass_parameters['total_mass'] = \
- conversion.component_masses_to_total_mass(**self.component_mass_pars)
+ self.mass_parameters["mass_ratio"] = conversion.component_masses_to_mass_ratio(
+ **self.component_mass_pars
+ )
+ self.mass_parameters[
+ "symmetric_mass_ratio"
+ ] = conversion.component_masses_to_symmetric_mass_ratio(
+ **self.component_mass_pars
+ )
+ self.mass_parameters["chirp_mass"] = conversion.component_masses_to_chirp_mass(
+ **self.component_mass_pars
+ )
+ self.mass_parameters["total_mass"] = conversion.component_masses_to_total_mass(
+ **self.component_mass_pars
+ )
self.component_tidal_parameters = dict(lambda_1=300, lambda_2=300)
self.all_component_pars = self.component_tidal_parameters.copy()
self.all_component_pars.update(self.component_mass_pars)
self.tidal_parameters = self.component_tidal_parameters.copy()
- self.tidal_parameters['lambda_tilde'] = \
- conversion.lambda_1_lambda_2_to_lambda_tilde(**self.all_component_pars)
- self.tidal_parameters['delta_lambda_tilde'] = \
- conversion.lambda_1_lambda_2_to_delta_lambda_tilde(**self.all_component_pars)
+ self.tidal_parameters[
+ "lambda_tilde"
+ ] = conversion.lambda_1_lambda_2_to_lambda_tilde(**self.all_component_pars)
+ self.tidal_parameters[
+ "delta_lambda_tilde"
+ ] = conversion.lambda_1_lambda_2_to_delta_lambda_tilde(
+ **self.all_component_pars
+ )
def tearDown(self):
del self.search_keys
del self.parameters
def bbh_convert(self):
- self.parameters, self.added_keys =\
- conversion.convert_to_lal_binary_black_hole_parameters(
- self.parameters)
+ (
+ self.parameters,
+ self.added_keys,
+ ) = conversion.convert_to_lal_binary_black_hole_parameters(self.parameters)
def bns_convert(self):
- self.parameters, self.added_keys = \
- conversion.convert_to_lal_binary_neutron_star_parameters(
- self.parameters)
+ (
+ self.parameters,
+ self.added_keys,
+ ) = conversion.convert_to_lal_binary_neutron_star_parameters(self.parameters)
def test_redshift_to_luminosity_distance(self):
- self.parameters['redshift'] = 1
- dl = conversion.redshift_to_luminosity_distance(
- self.parameters['redshift'])
+ self.parameters["redshift"] = 1
+ dl = conversion.redshift_to_luminosity_distance(self.parameters["redshift"])
self.bbh_convert()
- self.assertEqual(self.parameters['luminosity_distance'], dl)
+ self.assertEqual(self.parameters["luminosity_distance"], dl)
def test_comoving_to_luminosity_distance(self):
- self.parameters['comoving_distance'] = 1
+ self.parameters["comoving_distance"] = 1
dl = conversion.comoving_distance_to_luminosity_distance(
- self.parameters['comoving_distance'])
+ self.parameters["comoving_distance"]
+ )
self.bbh_convert()
- self.assertEqual(self.parameters['luminosity_distance'], dl)
+ self.assertEqual(self.parameters["luminosity_distance"], dl)
def test_source_to_lab_frame(self):
- self.parameters['test_source'] = 1
- self.parameters['redshift'] = 1
- lab = self.parameters['test_source'] * (1 + self.parameters['redshift'])
+ self.parameters["test_source"] = 1
+ self.parameters["redshift"] = 1
+ lab = self.parameters["test_source"] * (1 + self.parameters["redshift"])
self.bbh_convert()
- self.assertEqual(self.parameters['test'], lab)
+ self.assertEqual(self.parameters["test"], lab)
def _conversion_to_component_mass(self, keys):
for key in keys:
self.parameters[key] = self.mass_parameters[key]
self.bbh_convert()
self.assertAlmostEqual(
- max([abs(self.parameters[key] - self.component_mass_pars[key])
- for key in ['mass_1', 'mass_2']]), 0)
+ max(
+ [
+ abs(self.parameters[key] - self.component_mass_pars[key])
+ for key in ["mass_1", "mass_2"]
+ ]
+ ),
+ 0,
+ )
def test_chirp_mass_total_mass(self):
- self._conversion_to_component_mass(['chirp_mass', 'total_mass'])
+ self._conversion_to_component_mass(["chirp_mass", "total_mass"])
def test_chirp_mass_sym_mass_ratio(self):
- self._conversion_to_component_mass(['chirp_mass', 'symmetric_mass_ratio'])
+ self._conversion_to_component_mass(["chirp_mass", "symmetric_mass_ratio"])
def test_chirp_mass_mass_ratio(self):
- self._conversion_to_component_mass(['chirp_mass', 'mass_ratio'])
+ self._conversion_to_component_mass(["chirp_mass", "mass_ratio"])
def test_total_mass_sym_mass_ratio(self):
- self._conversion_to_component_mass(['total_mass', 'symmetric_mass_ratio'])
+ self._conversion_to_component_mass(["total_mass", "symmetric_mass_ratio"])
def test_total_mass_mass_ratio(self):
- self._conversion_to_component_mass(['total_mass', 'mass_ratio'])
+ self._conversion_to_component_mass(["total_mass", "mass_ratio"])
def test_total_mass_mass_1(self):
- self._conversion_to_component_mass(['total_mass', 'mass_1'])
+ self._conversion_to_component_mass(["total_mass", "mass_1"])
def test_total_mass_mass_2(self):
- self._conversion_to_component_mass(['total_mass', 'mass_2'])
+ self._conversion_to_component_mass(["total_mass", "mass_2"])
def test_sym_mass_ratio_mass_1(self):
- self._conversion_to_component_mass(['symmetric_mass_ratio', 'mass_1'])
+ self._conversion_to_component_mass(["symmetric_mass_ratio", "mass_1"])
def test_sym_mass_ratio_mass_2(self):
- self._conversion_to_component_mass(['symmetric_mass_ratio', 'mass_2'])
+ self._conversion_to_component_mass(["symmetric_mass_ratio", "mass_2"])
def test_mass_ratio_mass_1(self):
- self._conversion_to_component_mass(['mass_ratio', 'mass_1'])
+ self._conversion_to_component_mass(["mass_ratio", "mass_1"])
def test_mass_ratio_mass_2(self):
- self._conversion_to_component_mass(['mass_ratio', 'mass_2'])
+ self._conversion_to_component_mass(["mass_ratio", "mass_2"])
def test_bbh_aligned_spin_to_spherical(self):
- self.parameters['chi_1'] = -0.5
- a_1 = abs(self.parameters['chi_1'])
- tilt_1 = np.arccos(np.sign(self.parameters['chi_1']))
+ self.parameters["chi_1"] = -0.5
+ a_1 = abs(self.parameters["chi_1"])
+ tilt_1 = np.arccos(np.sign(self.parameters["chi_1"]))
phi_jl = 0.0
phi_12 = 0.0
self.bbh_convert()
self.assertDictEqual(
- {key: self.parameters[key]
- for key in ['a_1', 'tilt_1', 'phi_12', 'phi_jl']},
- dict(a_1=a_1, tilt_1=tilt_1, phi_jl=phi_jl, phi_12=phi_12))
+ {
+ key: self.parameters[key]
+ for key in ["a_1", "tilt_1", "phi_12", "phi_jl"]
+ },
+ dict(a_1=a_1, tilt_1=tilt_1, phi_jl=phi_jl, phi_12=phi_12),
+ )
def test_bbh_cos_angle_to_angle_conversion(self):
- self.parameters['cos_tilt_1'] = 1
- t1 = np.arccos(self.parameters['cos_tilt_1'])
+ self.parameters["cos_tilt_1"] = 1
+ t1 = np.arccos(self.parameters["cos_tilt_1"])
self.bbh_convert()
- self.assertEqual(self.parameters['tilt_1'], t1)
+ self.assertEqual(self.parameters["tilt_1"], t1)
def _conversion_to_component_tidal(self, keys):
for key in keys:
self.parameters[key] = self.tidal_parameters[key]
- for key in ['mass_1', 'mass_2']:
+ for key in ["mass_1", "mass_2"]:
self.parameters[key] = self.mass_parameters[key]
self.bns_convert()
- component_dict = {
- key: self.parameters[key] for key in ['lambda_1', 'lambda_2']}
+ component_dict = {key: self.parameters[key] for key in ["lambda_1", "lambda_2"]}
self.assertDictEqual(component_dict, self.component_tidal_parameters)
def test_lambda_tilde_delta_lambda_tilde(self):
- self._conversion_to_component_tidal(['lambda_tilde', 'delta_lambda_tilde'])
+ self._conversion_to_component_tidal(["lambda_tilde", "delta_lambda_tilde"])
def test_lambda_tilde(self):
- self._conversion_to_component_tidal(['lambda_tilde'])
+ self._conversion_to_component_tidal(["lambda_tilde"])
def test_lambda_1(self):
- self._conversion_to_component_tidal(['lambda_1'])
+ self._conversion_to_component_tidal(["lambda_1"])
class TestGenerateAllParameters(unittest.TestCase):
-
def setUp(self):
self.parameters = dict(
- mass_1=36., mass_2=29., a_1=0.4, a_2=0.3, tilt_1=0.5, tilt_2=1.0,
- phi_12=1.7, phi_jl=0.3, luminosity_distance=2000., theta_jn=0.4,
- psi=2.659, phase=1.3, geocent_time=1126259642.413, ra=1.375,
- dec=-1.2108, lambda_tilde=1000, delta_lambda_tilde=0)
+ mass_1=36.0,
+ mass_2=29.0,
+ a_1=0.4,
+ a_2=0.3,
+ tilt_1=0.5,
+ tilt_2=1.0,
+ phi_12=1.7,
+ phi_jl=0.3,
+ luminosity_distance=2000.0,
+ theta_jn=0.4,
+ psi=2.659,
+ phase=1.3,
+ geocent_time=1126259642.413,
+ ra=1.375,
+ dec=-1.2108,
+ lambda_tilde=1000,
+ delta_lambda_tilde=0,
+ )
self.expected_bbh_keys = [
- 'mass_1', 'mass_2', 'a_1', 'a_2', 'tilt_1', 'tilt_2', 'phi_12',
- 'phi_jl', 'luminosity_distance', 'theta_jn', 'psi', 'phase',
- 'geocent_time', 'ra', 'dec', 'reference_frequency',
- 'waveform_approximant', 'minimum_frequency', 'chirp_mass',
- 'total_mass', 'symmetric_mass_ratio', 'mass_ratio', 'iota',
- 'spin_1x', 'spin_1y', 'spin_1z', 'spin_2x', 'spin_2y', 'spin_2z',
- 'phi_1', 'phi_2', 'chi_eff', 'chi_1_in_plane', 'chi_2_in_plane',
- 'chi_p', 'cos_tilt_1', 'cos_tilt_2', 'redshift',
- 'comoving_distance', 'mass_1_source', 'mass_2_source',
- 'chirp_mass_source', 'total_mass_source'
+ "mass_1",
+ "mass_2",
+ "a_1",
+ "a_2",
+ "tilt_1",
+ "tilt_2",
+ "phi_12",
+ "phi_jl",
+ "luminosity_distance",
+ "theta_jn",
+ "psi",
+ "phase",
+ "geocent_time",
+ "ra",
+ "dec",
+ "reference_frequency",
+ "waveform_approximant",
+ "minimum_frequency",
+ "chirp_mass",
+ "total_mass",
+ "symmetric_mass_ratio",
+ "mass_ratio",
+ "iota",
+ "spin_1x",
+ "spin_1y",
+ "spin_1z",
+ "spin_2x",
+ "spin_2y",
+ "spin_2z",
+ "phi_1",
+ "phi_2",
+ "chi_eff",
+ "chi_1_in_plane",
+ "chi_2_in_plane",
+ "chi_p",
+ "cos_tilt_1",
+ "cos_tilt_2",
+ "redshift",
+ "comoving_distance",
+ "mass_1_source",
+ "mass_2_source",
+ "chirp_mass_source",
+ "total_mass_source",
]
self.expected_tidal_keys = [
- 'lambda_1', 'lambda_2', 'lambda_tilde', 'delta_lambda_tilde'
+ "lambda_1",
+ "lambda_2",
+ "lambda_tilde",
+ "delta_lambda_tilde",
]
def test_generate_all_bbh_parameters(self):
@@ -296,25 +411,28 @@ class TestGenerateAllParameters(unittest.TestCase):
class TestDistanceTransformations(unittest.TestCase):
-
def setUp(self):
self.distances = np.linspace(1, 1000, 100)
def test_luminosity_redshift_with_cosmology(self):
- z = conversion.luminosity_distance_to_redshift(self.distances, cosmology='WMAP9')
- dl = conversion.redshift_to_luminosity_distance(z, cosmology='WMAP9')
+ z = conversion.luminosity_distance_to_redshift(
+ self.distances, cosmology="WMAP9"
+ )
+ dl = conversion.redshift_to_luminosity_distance(z, cosmology="WMAP9")
self.assertAlmostEqual(max(abs(dl - self.distances)), 0, 4)
def test_comoving_redshift_with_cosmology(self):
- z = conversion.comoving_distance_to_redshift(self.distances, cosmology='WMAP9')
- dc = conversion.redshift_to_comoving_distance(z, cosmology='WMAP9')
+ z = conversion.comoving_distance_to_redshift(self.distances, cosmology="WMAP9")
+ dc = conversion.redshift_to_comoving_distance(z, cosmology="WMAP9")
self.assertAlmostEqual(max(abs(dc - self.distances)), 0, 4)
def test_comoving_luminosity_with_cosmology(self):
- dc = conversion.comoving_distance_to_luminosity_distance(self.distances, cosmology='WMAP9')
- dl = conversion.luminosity_distance_to_comoving_distance(dc, cosmology='WMAP9')
+ dc = conversion.comoving_distance_to_luminosity_distance(
+ self.distances, cosmology="WMAP9"
+ )
+ dl = conversion.luminosity_distance_to_comoving_distance(dc, cosmology="WMAP9")
self.assertAlmostEqual(max(abs(dl - self.distances)), 0, 4)
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/cosmology_test.py b/test/cosmology_test.py
index ca8ef65693497ea6f1c71affabea391e9084202d..2df9bd6b22fb0287833e9dfc5aaa01d866283a08 100644
--- a/test/cosmology_test.py
+++ b/test/cosmology_test.py
@@ -6,18 +6,17 @@ from bilby.gw import cosmology
class TestSetCosmology(unittest.TestCase):
-
def setUp(self):
pass
def test_setting_cosmology_with_string(self):
- cosmology.set_cosmology('WMAP9')
- self.assertEqual(cosmology.COSMOLOGY[1], 'WMAP9')
- cosmology.set_cosmology('Planck15')
+ cosmology.set_cosmology("WMAP9")
+ self.assertEqual(cosmology.COSMOLOGY[1], "WMAP9")
+ cosmology.set_cosmology("Planck15")
def test_setting_cosmology_with_astropy_object(self):
cosmology.set_cosmology(WMAP9)
- self.assertEqual(cosmology.COSMOLOGY[1], 'WMAP9')
+ self.assertEqual(cosmology.COSMOLOGY[1], "WMAP9")
cosmology.set_cosmology(Planck15)
def test_setting_cosmology_with_default(self):
@@ -27,30 +26,29 @@ class TestSetCosmology(unittest.TestCase):
def test_setting_cosmology_with_flat_lambda_cdm_dict(self):
cosmo_dict = dict(H0=67.7, Om0=0.3)
cosmology.set_cosmology(cosmo_dict)
- self.assertEqual(cosmology.COSMOLOGY[1][:13], 'FlatLambdaCDM')
+ self.assertEqual(cosmology.COSMOLOGY[1][:13], "FlatLambdaCDM")
def test_setting_cosmology_with_lambda_cdm_dict(self):
cosmo_dict = dict(H0=67.7, Om0=0.3, Ode0=0.7)
cosmology.set_cosmology(cosmo_dict)
- self.assertEqual(cosmology.COSMOLOGY[1][:9], 'LambdaCDM')
+ self.assertEqual(cosmology.COSMOLOGY[1][:9], "LambdaCDM")
def test_setting_cosmology_with_w_cdm_dict(self):
cosmo_dict = dict(H0=67.7, Om0=0.3, Ode0=0.7, w0=-1.0)
cosmology.set_cosmology(cosmo_dict)
- self.assertEqual(cosmology.COSMOLOGY[1][:4], 'wCDM')
+ self.assertEqual(cosmology.COSMOLOGY[1][:4], "wCDM")
class TestGetCosmology(unittest.TestCase):
-
def setUp(self):
pass
def test_getting_cosmology_with_string(self):
- self.assertEqual(cosmology.get_cosmology('WMAP9').name, 'WMAP9')
+ self.assertEqual(cosmology.get_cosmology("WMAP9").name, "WMAP9")
def test_getting_cosmology_with_default(self):
self.assertEqual(cosmology.get_cosmology(), cosmology.COSMOLOGY[0])
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/detector_test.py b/test/detector_test.py
index 18d75ad12e01defbb17826c38ca8d387a2a5ca2e..7f8b0512a854faf8ae58a0a3731bd740b985c616 100644
--- a/test/detector_test.py
+++ b/test/detector_test.py
@@ -1,7 +1,6 @@
from __future__ import absolute_import
import bilby
-import inspect
import unittest
import mock
from mock import MagicMock
@@ -16,7 +15,6 @@ import deepdish as dd
class TestInterferometerGeometry(unittest.TestCase):
-
def setUp(self):
self.length = 30
self.latitude = 1
@@ -24,16 +22,18 @@ class TestInterferometerGeometry(unittest.TestCase):
self.elevation = 3
self.xarm_azimuth = 4
self.yarm_azimuth = 5
- self.xarm_tilt = 0.
- self.yarm_tilt = 0.
- self.geometry = bilby.gw.detector.InterferometerGeometry(length=self.length,
- latitude=self.latitude,
- longitude=self.longitude,
- elevation=self.elevation,
- xarm_azimuth=self.xarm_azimuth,
- yarm_azimuth=self.yarm_azimuth,
- xarm_tilt=self.xarm_tilt,
- yarm_tilt=self.yarm_tilt)
+ self.xarm_tilt = 0.0
+ self.yarm_tilt = 0.0
+ self.geometry = bilby.gw.detector.InterferometerGeometry(
+ length=self.length,
+ latitude=self.latitude,
+ longitude=self.longitude,
+ elevation=self.elevation,
+ xarm_azimuth=self.xarm_azimuth,
+ yarm_azimuth=self.yarm_azimuth,
+ xarm_tilt=self.xarm_tilt,
+ yarm_tilt=self.yarm_tilt,
+ )
def tearDown(self):
del self.length
@@ -72,24 +72,24 @@ class TestInterferometerGeometry(unittest.TestCase):
def test_vertex_without_update(self):
_ = self.geometry.vertex
- with mock.patch('bilby.gw.utils.get_vertex_position_geocentric') as m:
+ with mock.patch("bilby.gw.utils.get_vertex_position_geocentric") as m:
m.return_value = np.array([1])
self.assertFalse(np.array_equal(self.geometry.vertex, np.array([1])))
def test_vertex_with_latitude_update(self):
- with mock.patch('bilby.gw.utils.get_vertex_position_geocentric') as m:
+ with mock.patch("bilby.gw.utils.get_vertex_position_geocentric") as m:
m.return_value = np.array([1])
self.geometry.latitude = 5
self.assertEqual(self.geometry.vertex, np.array([1]))
def test_vertex_with_longitude_update(self):
- with mock.patch('bilby.gw.utils.get_vertex_position_geocentric') as m:
+ with mock.patch("bilby.gw.utils.get_vertex_position_geocentric") as m:
m.return_value = np.array([1])
self.geometry.longitude = 5
self.assertEqual(self.geometry.vertex, np.array([1]))
def test_vertex_with_elevation_update(self):
- with mock.patch('bilby.gw.utils.get_vertex_position_geocentric') as m:
+ with mock.patch("bilby.gw.utils.get_vertex_position_geocentric") as m:
m.return_value = np.array([1])
self.geometry.elevation = 5
self.assertEqual(self.geometry.vertex, np.array([1]))
@@ -98,109 +98,103 @@ class TestInterferometerGeometry(unittest.TestCase):
_ = self.geometry.x
self.geometry.unit_vector_along_arm = MagicMock(return_value=np.array([1]))
- self.assertFalse(np.array_equal(self.geometry.x,
- np.array([1])))
+ self.assertFalse(np.array_equal(self.geometry.x, np.array([1])))
def test_x_with_xarm_tilt_update(self):
self.geometry.unit_vector_along_arm = MagicMock(return_value=np.array([1]))
self.geometry.xarm_tilt = 0
- self.assertTrue(np.array_equal(self.geometry.x,
- np.array([1])))
+ self.assertTrue(np.array_equal(self.geometry.x, np.array([1])))
def test_x_with_xarm_azimuth_update(self):
self.geometry.unit_vector_along_arm = MagicMock(return_value=np.array([1]))
self.geometry.xarm_azimuth = 0
- self.assertTrue(np.array_equal(self.geometry.x,
- np.array([1])))
+ self.assertTrue(np.array_equal(self.geometry.x, np.array([1])))
def test_x_with_longitude_update(self):
self.geometry.unit_vector_along_arm = MagicMock(return_value=np.array([1]))
self.geometry.longitude = 0
- self.assertTrue(np.array_equal(self.geometry.x,
- np.array([1])))
+ self.assertTrue(np.array_equal(self.geometry.x, np.array([1])))
def test_x_with_latitude_update(self):
self.geometry.unit_vector_along_arm = MagicMock(return_value=np.array([1]))
self.geometry.latitude = 0
- self.assertTrue(np.array_equal(self.geometry.x,
- np.array([1])))
+ self.assertTrue(np.array_equal(self.geometry.x, np.array([1])))
def test_y_without_update(self):
_ = self.geometry.y
self.geometry.unit_vector_along_arm = MagicMock(return_value=np.array([1]))
- self.assertFalse(np.array_equal(self.geometry.y,
- np.array([1])))
+ self.assertFalse(np.array_equal(self.geometry.y, np.array([1])))
def test_y_with_yarm_tilt_update(self):
self.geometry.unit_vector_along_arm = MagicMock(return_value=np.array([1]))
self.geometry.yarm_tilt = 0
- self.assertTrue(np.array_equal(self.geometry.y,
- np.array([1])))
+ self.assertTrue(np.array_equal(self.geometry.y, np.array([1])))
def test_y_with_yarm_azimuth_update(self):
self.geometry.unit_vector_along_arm = MagicMock(return_value=np.array([1]))
self.geometry.yarm_azimuth = 0
- self.assertTrue(np.array_equal(self.geometry.y,
- np.array([1])))
+ self.assertTrue(np.array_equal(self.geometry.y, np.array([1])))
def test_y_with_longitude_update(self):
self.geometry.unit_vector_along_arm = MagicMock(return_value=np.array([1]))
self.geometry.longitude = 0
- self.assertTrue(np.array_equal(self.geometry.y,
- np.array([1])))
+ self.assertTrue(np.array_equal(self.geometry.y, np.array([1])))
def test_y_with_latitude_update(self):
self.geometry.unit_vector_along_arm = MagicMock(return_value=np.array([1]))
self.geometry.latitude = 0
- self.assertTrue(np.array_equal(self.geometry.y,
- np.array([1])))
+ self.assertTrue(np.array_equal(self.geometry.y, np.array([1])))
def test_detector_tensor_without_update(self):
_ = self.geometry.detector_tensor
- with mock.patch('numpy.einsum') as m:
+ with mock.patch("numpy.einsum") as m:
m.return_value = 1
- expected = np.array([[-9.24529394e-06, 1.02425803e-04, 3.24550668e-04],
- [1.02425803e-04, 1.37390844e-03, -8.61137566e-03],
- [3.24550668e-04, -8.61137566e-03, -1.36466315e-03]])
+ expected = np.array(
+ [
+ [-9.24529394e-06, 1.02425803e-04, 3.24550668e-04],
+ [1.02425803e-04, 1.37390844e-03, -8.61137566e-03],
+ [3.24550668e-04, -8.61137566e-03, -1.36466315e-03],
+ ]
+ )
self.assertTrue(np.allclose(expected, self.geometry.detector_tensor))
def test_detector_tensor_with_x_azimuth_update(self):
_ = self.geometry.detector_tensor
- with mock.patch('numpy.einsum') as m:
+ with mock.patch("numpy.einsum") as m:
m.return_value = 1
self.geometry.xarm_azimuth = 1
self.assertEqual(0, self.geometry.detector_tensor)
def test_detector_tensor_with_y_azimuth_update(self):
_ = self.geometry.detector_tensor
- with mock.patch('numpy.einsum') as m:
+ with mock.patch("numpy.einsum") as m:
m.return_value = 1
self.geometry.yarm_azimuth = 1
self.assertEqual(0, self.geometry.detector_tensor)
def test_detector_tensor_with_x_tilt_update(self):
_ = self.geometry.detector_tensor
- with mock.patch('numpy.einsum') as m:
+ with mock.patch("numpy.einsum") as m:
m.return_value = 1
self.geometry.xarm_tilt = 1
self.assertEqual(0, self.geometry.detector_tensor)
def test_detector_tensor_with_y_tilt_update(self):
_ = self.geometry.detector_tensor
- with mock.patch('numpy.einsum') as m:
+ with mock.patch("numpy.einsum") as m:
m.return_value = 1
self.geometry.yarm_tilt = 1
self.assertEqual(0, self.geometry.detector_tensor)
def test_detector_tensor_with_longitude_update(self):
- with mock.patch('numpy.einsum') as m:
+ with mock.patch("numpy.einsum") as m:
m.return_value = 1
self.geometry.longitude = 1
self.assertEqual(0, self.geometry.detector_tensor)
def test_detector_tensor_with_latitude_update(self):
- with mock.patch('numpy.einsum') as m:
+ with mock.patch("numpy.einsum") as m:
_ = self.geometry.detector_tensor
m.return_value = 1
self.geometry.latitude = 1
@@ -208,39 +202,49 @@ class TestInterferometerGeometry(unittest.TestCase):
def test_unit_vector_along_arm_default(self):
with self.assertRaises(ValueError):
- self.geometry.unit_vector_along_arm('z')
+ self.geometry.unit_vector_along_arm("z")
def test_unit_vector_along_arm_x(self):
- with mock.patch('numpy.array') as m:
+ with mock.patch("numpy.array") as m:
m.return_value = 1
self.geometry.xarm_tilt = 0
self.geometry.xarm_azimuth = 0
self.geometry.yarm_tilt = 0
self.geometry.yarm_azimuth = 90
- self.assertAlmostEqual(self.geometry.unit_vector_along_arm('x'), 1)
+ self.assertAlmostEqual(self.geometry.unit_vector_along_arm("x"), 1)
def test_unit_vector_along_arm_y(self):
- with mock.patch('numpy.array') as m:
+ with mock.patch("numpy.array") as m:
m.return_value = 1
self.geometry.xarm_tilt = 0
self.geometry.xarm_azimuth = 90
self.geometry.yarm_tilt = 0
self.geometry.yarm_azimuth = 180
- self.assertAlmostEqual(self.geometry.unit_vector_along_arm('y'), -1)
+ self.assertAlmostEqual(self.geometry.unit_vector_along_arm("y"), -1)
def test_repr(self):
- expected = 'InterferometerGeometry(length={}, latitude={}, longitude={}, elevation={}, xarm_azimuth={}, ' \
- 'yarm_azimuth={}, xarm_tilt={}, yarm_tilt={})' \
- .format(float(self.length), float(self.latitude), float(self.longitude), float(self.elevation),
- float(self.xarm_azimuth), float(self.yarm_azimuth), float(self.xarm_tilt), float(self.yarm_tilt))
+ expected = (
+ "InterferometerGeometry(length={}, latitude={}, longitude={}, elevation={}, xarm_azimuth={}, "
+ "yarm_azimuth={}, xarm_tilt={}, yarm_tilt={})".format(
+ float(self.length),
+ float(self.latitude),
+ float(self.longitude),
+ float(self.elevation),
+ float(self.xarm_azimuth),
+ float(self.yarm_azimuth),
+ float(self.xarm_tilt),
+ float(self.yarm_tilt),
+ )
+ )
self.assertEqual(expected, repr(self.geometry))
class TestInterferometer(unittest.TestCase):
-
def setUp(self):
- self.name = 'name'
- self.power_spectral_density = bilby.gw.detector.PowerSpectralDensity.from_aligo()
+ self.name = "name"
+ self.power_spectral_density = (
+ bilby.gw.detector.PowerSpectralDensity.from_aligo()
+ )
self.minimum_frequency = 10
self.maximum_frequency = 20
self.length = 30
@@ -249,29 +253,41 @@ class TestInterferometer(unittest.TestCase):
self.elevation = 3
self.xarm_azimuth = 4
self.yarm_azimuth = 5
- self.xarm_tilt = 0.
- self.yarm_tilt = 0.
+ self.xarm_tilt = 0.0
+ self.yarm_tilt = 0.0
# noinspection PyTypeChecker
- self.ifo = bilby.gw.detector.Interferometer(name=self.name, power_spectral_density=self.power_spectral_density,
- minimum_frequency=self.minimum_frequency,
- maximum_frequency=self.maximum_frequency, length=self.length,
- latitude=self.latitude, longitude=self.longitude,
- elevation=self.elevation,
- xarm_azimuth=self.xarm_azimuth, yarm_azimuth=self.yarm_azimuth,
- xarm_tilt=self.xarm_tilt, yarm_tilt=self.yarm_tilt)
+ self.ifo = bilby.gw.detector.Interferometer(
+ name=self.name,
+ power_spectral_density=self.power_spectral_density,
+ minimum_frequency=self.minimum_frequency,
+ maximum_frequency=self.maximum_frequency,
+ length=self.length,
+ latitude=self.latitude,
+ longitude=self.longitude,
+ elevation=self.elevation,
+ xarm_azimuth=self.xarm_azimuth,
+ yarm_azimuth=self.yarm_azimuth,
+ xarm_tilt=self.xarm_tilt,
+ yarm_tilt=self.yarm_tilt,
+ )
self.ifo.strain_data.set_from_frequency_domain_strain(
- np.linspace(0, 4096, 4097), sampling_frequency=4096, duration=2)
- self.outdir = 'outdir'
+ np.linspace(0, 4096, 4097), sampling_frequency=4096, duration=2
+ )
+ self.outdir = "outdir"
self.injection_polarizations = dict()
np.random.seed(42)
- self.injection_polarizations['plus'] = np.random.random(4097)
- self.injection_polarizations['cross'] = np.random.random(4097)
+ self.injection_polarizations["plus"] = np.random.random(4097)
+ self.injection_polarizations["cross"] = np.random.random(4097)
self.waveform_generator = MagicMock()
- self.wg_polarizations = dict(plus=np.random.random(4097), cross=np.random.random(4097))
- self.waveform_generator.frequency_domain_strain = lambda _: self.wg_polarizations
- self.parameters = dict(ra=0., dec=0., geocent_time=0., psi=0.)
+ self.wg_polarizations = dict(
+ plus=np.random.random(4097), cross=np.random.random(4097)
+ )
+ self.waveform_generator.frequency_domain_strain = (
+ lambda _: self.wg_polarizations
+ )
+ self.parameters = dict(ra=0.0, dec=0.0, geocent_time=0.0, psi=0.0)
bilby.core.utils.check_directory_exists_and_if_not_mkdir(self.outdir)
@@ -308,16 +324,19 @@ class TestInterferometer(unittest.TestCase):
self.assertEqual(self.ifo.strain_data.maximum_frequency, self.maximum_frequency)
def test_antenna_response_default(self):
- with mock.patch('bilby.gw.utils.get_polarization_tensor') as m:
- with mock.patch('numpy.einsum') as n:
+ with mock.patch("bilby.gw.utils.get_polarization_tensor") as m:
+ with mock.patch("numpy.einsum") as n:
m.return_value = 0
n.return_value = 1
- self.assertEqual(self.ifo.antenna_response(234, 52, 54, 76, 'plus'), 1)
+ self.assertEqual(self.ifo.antenna_response(234, 52, 54, 76, "plus"), 1)
def test_antenna_response_einsum(self):
- with mock.patch('bilby.gw.utils.get_polarization_tensor') as m:
+ with mock.patch("bilby.gw.utils.get_polarization_tensor") as m:
m.return_value = np.ones((3, 3))
- self.assertAlmostEqual(self.ifo.antenna_response(234, 52, 54, 76, 'plus'), self.ifo.detector_tensor.sum())
+ self.assertAlmostEqual(
+ self.ifo.antenna_response(234, 52, 54, 76, "plus"),
+ self.ifo.detector_tensor.sum(),
+ )
def test_get_detector_response_default_behaviour(self):
self.ifo.antenna_response = MagicMock(return_value=1)
@@ -329,8 +348,11 @@ class TestInterferometer(unittest.TestCase):
plus = np.linspace(0, 4096, 4097)
response = self.ifo.get_detector_response(
waveform_polarizations=dict(plus=plus),
- parameters=dict(ra=0, dec=0, geocent_time=0, psi=0))
- self.assertTrue(np.array_equal(response, plus * self.ifo.frequency_mask * np.exp(-0j)))
+ parameters=dict(ra=0, dec=0, geocent_time=0, psi=0),
+ )
+ self.assertTrue(
+ np.array_equal(response, plus * self.ifo.frequency_mask * np.exp(-0j))
+ )
def test_get_detector_response_with_dt(self):
self.ifo.antenna_response = MagicMock(return_value=1)
@@ -341,8 +363,13 @@ class TestInterferometer(unittest.TestCase):
plus = np.linspace(0, 4096, 4097)
response = self.ifo.get_detector_response(
waveform_polarizations=dict(plus=plus),
- parameters=dict(ra=0, dec=0, geocent_time=0, psi=0))
- expected_response = plus * self.ifo.frequency_mask * np.exp(-1j * 2 * np.pi * self.ifo.frequency_array)
+ parameters=dict(ra=0, dec=0, geocent_time=0, psi=0),
+ )
+ expected_response = (
+ plus
+ * self.ifo.frequency_mask
+ * np.exp(-1j * 2 * np.pi * self.ifo.frequency_array)
+ )
self.assertTrue(np.allclose(abs(expected_response), abs(response)))
def test_get_detector_response_multiple_modes(self):
@@ -355,106 +382,172 @@ class TestInterferometer(unittest.TestCase):
cross = np.linspace(0, 4096, 4097)
response = self.ifo.get_detector_response(
waveform_polarizations=dict(plus=plus, cross=cross),
- parameters=dict(ra=0, dec=0, geocent_time=0, psi=0))
- self.assertTrue(np.array_equal(response, (plus + cross) * self.ifo.frequency_mask * np.exp(-0j)))
+ parameters=dict(ra=0, dec=0, geocent_time=0, psi=0),
+ )
+ self.assertTrue(
+ np.array_equal(
+ response, (plus + cross) * self.ifo.frequency_mask * np.exp(-0j)
+ )
+ )
def test_inject_signal_from_waveform_polarizations_correct_injection(self):
original_strain = self.ifo.strain_data.frequency_domain_strain
- self.ifo.get_detector_response = lambda x, params: x['plus'] + x['cross']
- self.ifo.inject_signal_from_waveform_polarizations(parameters=self.parameters,
- injection_polarizations=self.injection_polarizations)
- expected = self.injection_polarizations['plus'] + self.injection_polarizations['cross'] + original_strain
- self.assertTrue(np.array_equal(expected, self.ifo.strain_data._frequency_domain_strain))
+ self.ifo.get_detector_response = lambda x, params: x["plus"] + x["cross"]
+ self.ifo.inject_signal_from_waveform_polarizations(
+ parameters=self.parameters,
+ injection_polarizations=self.injection_polarizations,
+ )
+ expected = (
+ self.injection_polarizations["plus"]
+ + self.injection_polarizations["cross"]
+ + original_strain
+ )
+ self.assertTrue(
+ np.array_equal(expected, self.ifo.strain_data._frequency_domain_strain)
+ )
def test_inject_signal_from_waveform_polarizations_update_time_domain_strain(self):
original_td_strain = self.ifo.strain_data.time_domain_strain
- self.ifo.get_detector_response = lambda x, params: x['plus'] + x['cross']
- self.ifo.inject_signal_from_waveform_polarizations(parameters=self.parameters,
- injection_polarizations=self.injection_polarizations)
- self.assertFalse(np.array_equal(original_td_strain, self.ifo.strain_data.time_domain_strain))
+ self.ifo.get_detector_response = lambda x, params: x["plus"] + x["cross"]
+ self.ifo.inject_signal_from_waveform_polarizations(
+ parameters=self.parameters,
+ injection_polarizations=self.injection_polarizations,
+ )
+ self.assertFalse(
+ np.array_equal(original_td_strain, self.ifo.strain_data.time_domain_strain)
+ )
def test_inject_signal_from_waveform_polarizations_meta_data(self):
- self.ifo.get_detector_response = lambda x, params: x['plus'] + x['cross']
- self.ifo.inject_signal_from_waveform_polarizations(parameters=self.parameters,
- injection_polarizations=self.injection_polarizations)
- signal_ifo_expected = self.injection_polarizations['plus'] + self.injection_polarizations['cross']
- self.assertAlmostEqual(self.ifo.optimal_snr_squared(signal=signal_ifo_expected).real,
- self.ifo.meta_data['optimal_SNR']**2, 10)
- self.assertAlmostEqual(self.ifo.matched_filter_snr(signal=signal_ifo_expected),
- self.ifo.meta_data['matched_filter_SNR'], 10)
- self.assertDictEqual(self.parameters,
- self.ifo.meta_data['parameters'])
+ self.ifo.get_detector_response = lambda x, params: x["plus"] + x["cross"]
+ self.ifo.inject_signal_from_waveform_polarizations(
+ parameters=self.parameters,
+ injection_polarizations=self.injection_polarizations,
+ )
+ signal_ifo_expected = (
+ self.injection_polarizations["plus"] + self.injection_polarizations["cross"]
+ )
+ self.assertAlmostEqual(
+ self.ifo.optimal_snr_squared(signal=signal_ifo_expected).real,
+ self.ifo.meta_data["optimal_SNR"] ** 2,
+ 10,
+ )
+ self.assertAlmostEqual(
+ self.ifo.matched_filter_snr(signal=signal_ifo_expected),
+ self.ifo.meta_data["matched_filter_SNR"],
+ 10,
+ )
+ self.assertDictEqual(self.parameters, self.ifo.meta_data["parameters"])
def test_inject_signal_from_waveform_polarizations_incorrect_length(self):
- self.injection_polarizations['plus'] = np.random.random(1000)
- self.injection_polarizations['cross'] = np.random.random(1000)
- self.ifo.get_detector_response = lambda x, params: x['plus'] + x['cross']
+ self.injection_polarizations["plus"] = np.random.random(1000)
+ self.injection_polarizations["cross"] = np.random.random(1000)
+ self.ifo.get_detector_response = lambda x, params: x["plus"] + x["cross"]
with self.assertRaises(ValueError):
- self.ifo.inject_signal_from_waveform_polarizations(parameters=self.parameters,
- injection_polarizations=self.injection_polarizations)
+ self.ifo.inject_signal_from_waveform_polarizations(
+ parameters=self.parameters,
+ injection_polarizations=self.injection_polarizations,
+ )
- @patch.object(bilby.core.utils.logger, 'warning')
+ @patch.object(bilby.core.utils.logger, "warning")
def test_inject_signal_outside_segment_logs_warning(self, m):
- self.parameters['geocent_time'] = 24345.
- self.ifo.get_detector_response = lambda x, params: x['plus'] + x['cross']
- self.ifo.inject_signal_from_waveform_polarizations(parameters=self.parameters,
- injection_polarizations=self.injection_polarizations)
+ self.parameters["geocent_time"] = 24345.0
+ self.ifo.get_detector_response = lambda x, params: x["plus"] + x["cross"]
+ self.ifo.inject_signal_from_waveform_polarizations(
+ parameters=self.parameters,
+ injection_polarizations=self.injection_polarizations,
+ )
self.assertTrue(m.called)
def test_inject_signal_from_waveform_generator_correct_return_value(self):
- self.ifo.get_detector_response = lambda x, params: x['plus'] + x['cross']
- returned_polarizations = self.ifo.inject_signal_from_waveform_generator(parameters=self.parameters,
- waveform_generator=self.waveform_generator)
- self.assertTrue(np.array_equal(self.wg_polarizations['plus'], returned_polarizations['plus']))
- self.assertTrue(np.array_equal(self.wg_polarizations['cross'], returned_polarizations['cross']))
-
- @patch.object(bilby.gw.detector.Interferometer, 'inject_signal_from_waveform_generator')
+ self.ifo.get_detector_response = lambda x, params: x["plus"] + x["cross"]
+ returned_polarizations = self.ifo.inject_signal_from_waveform_generator(
+ parameters=self.parameters, waveform_generator=self.waveform_generator
+ )
+ self.assertTrue(
+ np.array_equal(
+ self.wg_polarizations["plus"], returned_polarizations["plus"]
+ )
+ )
+ self.assertTrue(
+ np.array_equal(
+ self.wg_polarizations["cross"], returned_polarizations["cross"]
+ )
+ )
+
+ @patch.object(
+ bilby.gw.detector.Interferometer, "inject_signal_from_waveform_generator"
+ )
def test_inject_signal_with_waveform_generator_correct_call(self, m):
- self.ifo.get_detector_response = lambda x, params: x['plus'] + x['cross']
- _ = self.ifo.inject_signal(parameters=self.parameters,
- waveform_generator=self.waveform_generator)
- m.assert_called_with(parameters=self.parameters,
- waveform_generator=self.waveform_generator)
+ self.ifo.get_detector_response = lambda x, params: x["plus"] + x["cross"]
+ _ = self.ifo.inject_signal(
+ parameters=self.parameters, waveform_generator=self.waveform_generator
+ )
+ m.assert_called_with(
+ parameters=self.parameters, waveform_generator=self.waveform_generator
+ )
def test_inject_signal_from_waveform_generator_correct_injection(self):
original_strain = self.ifo.strain_data.frequency_domain_strain
- self.ifo.get_detector_response = lambda x, params: x['plus'] + x['cross']
- injection_polarizations = self.ifo.inject_signal_from_waveform_generator(parameters=self.parameters,
- waveform_generator=self.waveform_generator)
- expected = injection_polarizations['plus'] + injection_polarizations['cross'] + original_strain
- self.assertTrue(np.array_equal(expected, self.ifo.strain_data._frequency_domain_strain))
+ self.ifo.get_detector_response = lambda x, params: x["plus"] + x["cross"]
+ injection_polarizations = self.ifo.inject_signal_from_waveform_generator(
+ parameters=self.parameters, waveform_generator=self.waveform_generator
+ )
+ expected = (
+ injection_polarizations["plus"]
+ + injection_polarizations["cross"]
+ + original_strain
+ )
+ self.assertTrue(
+ np.array_equal(expected, self.ifo.strain_data._frequency_domain_strain)
+ )
def test_inject_signal_with_injection_polarizations(self):
original_strain = self.ifo.strain_data.frequency_domain_strain
- self.ifo.get_detector_response = lambda x, params: x['plus'] + x['cross']
- self.ifo.inject_signal(parameters=self.parameters,
- injection_polarizations=self.injection_polarizations)
- expected = self.injection_polarizations['plus'] + self.injection_polarizations['cross'] + original_strain
- self.assertTrue(np.array_equal(expected, self.ifo.strain_data._frequency_domain_strain))
-
- @patch.object(bilby.gw.detector.Interferometer, 'inject_signal_from_waveform_polarizations')
+ self.ifo.get_detector_response = lambda x, params: x["plus"] + x["cross"]
+ self.ifo.inject_signal(
+ parameters=self.parameters,
+ injection_polarizations=self.injection_polarizations,
+ )
+ expected = (
+ self.injection_polarizations["plus"]
+ + self.injection_polarizations["cross"]
+ + original_strain
+ )
+ self.assertTrue(
+ np.array_equal(expected, self.ifo.strain_data._frequency_domain_strain)
+ )
+
+ @patch.object(
+ bilby.gw.detector.Interferometer, "inject_signal_from_waveform_polarizations"
+ )
def test_inject_signal_with_injection_polarizations_and_waveform_generator(self, m):
- self.ifo.get_detector_response = lambda x, params: x['plus'] + x['cross']
- _ = self.ifo.inject_signal(parameters=self.parameters,
- waveform_generator=self.waveform_generator,
- injection_polarizations=self.injection_polarizations)
- m.assert_called_with(parameters=self.parameters,
- injection_polarizations=self.injection_polarizations)
+ self.ifo.get_detector_response = lambda x, params: x["plus"] + x["cross"]
+ _ = self.ifo.inject_signal(
+ parameters=self.parameters,
+ waveform_generator=self.waveform_generator,
+ injection_polarizations=self.injection_polarizations,
+ )
+ m.assert_called_with(
+ parameters=self.parameters,
+ injection_polarizations=self.injection_polarizations,
+ )
with self.assertRaises(ValueError):
- m.assert_called_with(parameters=self.parameters,
- injection_polarizations=self.wg_polarizations)
+ m.assert_called_with(
+ parameters=self.parameters,
+ injection_polarizations=self.wg_polarizations,
+ )
def test_inject_signal_raises_value_error(self):
with self.assertRaises(ValueError):
self.ifo.inject_signal(injection_polarizations=None, parameters=None)
def test_time_delay_from_geocenter(self):
- with mock.patch('bilby.gw.utils.time_delay_geocentric') as m:
+ with mock.patch("bilby.gw.utils.time_delay_geocentric") as m:
m.return_value = 1
self.assertEqual(self.ifo.time_delay_from_geocenter(1, 2, 3), 1)
def test_vertex_position_geocentric(self):
- with mock.patch('bilby.gw.utils.get_vertex_position_geocentric') as m:
+ with mock.patch("bilby.gw.utils.get_vertex_position_geocentric") as m:
m.return_value = 1
self.assertEqual(self.ifo.vertex_position_geocentric(), 1)
@@ -463,13 +556,16 @@ class TestInterferometer(unittest.TestCase):
Merely checks parameters are given in the right order and the frequency
mask is applied.
"""
- with mock.patch('bilby.gw.utils.noise_weighted_inner_product') as m:
+ with mock.patch("bilby.gw.utils.noise_weighted_inner_product") as m:
m.side_effect = lambda a, b, c, d: [a, b, c, d]
signal = np.ones_like(self.ifo.power_spectral_density_array)
mask = self.ifo.frequency_mask
- expected = [signal[mask], signal[mask],
- self.ifo.power_spectral_density_array[mask],
- self.ifo.strain_data.duration]
+ expected = [
+ signal[mask],
+ signal[mask],
+ self.ifo.power_spectral_density_array[mask],
+ self.ifo.strain_data.duration,
+ ]
actual = self.ifo.optimal_snr_squared(signal=signal)
self.assertTrue(np.array_equal(expected[0], actual[0]))
self.assertTrue(np.array_equal(expected[1], actual[1]))
@@ -477,22 +573,35 @@ class TestInterferometer(unittest.TestCase):
self.assertEqual(expected[3], actual[3])
def test_repr(self):
- expected = 'Interferometer(name=\'{}\', power_spectral_density={}, minimum_frequency={}, ' \
- 'maximum_frequency={}, length={}, latitude={}, longitude={}, elevation={}, xarm_azimuth={}, ' \
- 'yarm_azimuth={}, xarm_tilt={}, yarm_tilt={})' \
- .format(self.name, self.power_spectral_density, float(self.minimum_frequency),
- float(self.maximum_frequency), float(self.length), float(self.latitude), float(self.longitude),
- float(self.elevation), float(self.xarm_azimuth), float(self.yarm_azimuth), float(self.xarm_tilt),
- float(self.yarm_tilt))
+ expected = (
+ "Interferometer(name='{}', power_spectral_density={}, minimum_frequency={}, "
+ "maximum_frequency={}, length={}, latitude={}, longitude={}, elevation={}, xarm_azimuth={}, "
+ "yarm_azimuth={}, xarm_tilt={}, yarm_tilt={})".format(
+ self.name,
+ self.power_spectral_density,
+ float(self.minimum_frequency),
+ float(self.maximum_frequency),
+ float(self.length),
+ float(self.latitude),
+ float(self.longitude),
+ float(self.elevation),
+ float(self.xarm_azimuth),
+ float(self.yarm_azimuth),
+ float(self.xarm_tilt),
+ float(self.yarm_tilt),
+ )
+ )
self.assertEqual(expected, repr(self.ifo))
def test_to_and_from_hdf5_loading(self):
if sys.version_info[0] < 3:
with self.assertRaises(NotImplementedError):
- self.ifo.to_hdf5(outdir='outdir', label='test')
+ self.ifo.to_hdf5(outdir="outdir", label="test")
else:
- self.ifo.to_hdf5(outdir='outdir', label='test')
- filename = self.ifo._hdf5_filename_from_outdir_label(outdir='outdir', label='test')
+ self.ifo.to_hdf5(outdir="outdir", label="test")
+ filename = self.ifo._hdf5_filename_from_outdir_label(
+ outdir="outdir", label="test"
+ )
recovered_ifo = bilby.gw.detector.Interferometer.from_hdf5(filename)
self.assertEqual(self.ifo, recovered_ifo)
@@ -500,19 +609,24 @@ class TestInterferometer(unittest.TestCase):
if sys.version_info[0] < 3:
pass
else:
- bilby.core.utils.check_directory_exists_and_if_not_mkdir('outdir')
- dd.io.save('./outdir/psd.h5', self.power_spectral_density)
- filename = self.ifo._hdf5_filename_from_outdir_label(outdir='outdir', label='psd')
+ bilby.core.utils.check_directory_exists_and_if_not_mkdir("outdir")
+ dd.io.save("./outdir/psd.h5", self.power_spectral_density)
+ filename = self.ifo._hdf5_filename_from_outdir_label(
+ outdir="outdir", label="psd"
+ )
with self.assertRaises(TypeError):
bilby.gw.detector.Interferometer.from_hdf5(filename)
class TestInterferometerEquals(unittest.TestCase):
-
def setUp(self):
- self.name = 'name'
- self.power_spectral_density_1 = bilby.gw.detector.PowerSpectralDensity.from_aligo()
- self.power_spectral_density_2 = bilby.gw.detector.PowerSpectralDensity.from_aligo()
+ self.name = "name"
+ self.power_spectral_density_1 = (
+ bilby.gw.detector.PowerSpectralDensity.from_aligo()
+ )
+ self.power_spectral_density_2 = (
+ bilby.gw.detector.PowerSpectralDensity.from_aligo()
+ )
self.minimum_frequency = 10
self.maximum_frequency = 20
self.length = 30
@@ -521,34 +635,49 @@ class TestInterferometerEquals(unittest.TestCase):
self.elevation = 3
self.xarm_azimuth = 4
self.yarm_azimuth = 5
- self.xarm_tilt = 0.
- self.yarm_tilt = 0.
+ self.xarm_tilt = 0.0
+ self.yarm_tilt = 0.0
# noinspection PyTypeChecker
self.duration = 1
self.sampling_frequency = 200
- self.frequency_array = bilby.utils.create_frequency_series(sampling_frequency=self.sampling_frequency,
- duration=self.duration)
+ self.frequency_array = bilby.utils.create_frequency_series(
+ sampling_frequency=self.sampling_frequency, duration=self.duration
+ )
self.strain = self.frequency_array
- self.ifo_1 = bilby.gw.detector.Interferometer(name=self.name,
- power_spectral_density=self.power_spectral_density_1,
- minimum_frequency=self.minimum_frequency,
- maximum_frequency=self.maximum_frequency, length=self.length,
- latitude=self.latitude, longitude=self.longitude,
- elevation=self.elevation,
- xarm_azimuth=self.xarm_azimuth, yarm_azimuth=self.yarm_azimuth,
- xarm_tilt=self.xarm_tilt, yarm_tilt=self.yarm_tilt)
- self.ifo_2 = bilby.gw.detector.Interferometer(name=self.name,
- power_spectral_density=self.power_spectral_density_2,
- minimum_frequency=self.minimum_frequency,
- maximum_frequency=self.maximum_frequency, length=self.length,
- latitude=self.latitude, longitude=self.longitude,
- elevation=self.elevation,
- xarm_azimuth=self.xarm_azimuth, yarm_azimuth=self.yarm_azimuth,
- xarm_tilt=self.xarm_tilt, yarm_tilt=self.yarm_tilt)
- self.ifo_1.set_strain_data_from_frequency_domain_strain(frequency_array=self.frequency_array,
- frequency_domain_strain=self.strain)
- self.ifo_2.set_strain_data_from_frequency_domain_strain(frequency_array=self.frequency_array,
- frequency_domain_strain=self.strain)
+ self.ifo_1 = bilby.gw.detector.Interferometer(
+ name=self.name,
+ power_spectral_density=self.power_spectral_density_1,
+ minimum_frequency=self.minimum_frequency,
+ maximum_frequency=self.maximum_frequency,
+ length=self.length,
+ latitude=self.latitude,
+ longitude=self.longitude,
+ elevation=self.elevation,
+ xarm_azimuth=self.xarm_azimuth,
+ yarm_azimuth=self.yarm_azimuth,
+ xarm_tilt=self.xarm_tilt,
+ yarm_tilt=self.yarm_tilt,
+ )
+ self.ifo_2 = bilby.gw.detector.Interferometer(
+ name=self.name,
+ power_spectral_density=self.power_spectral_density_2,
+ minimum_frequency=self.minimum_frequency,
+ maximum_frequency=self.maximum_frequency,
+ length=self.length,
+ latitude=self.latitude,
+ longitude=self.longitude,
+ elevation=self.elevation,
+ xarm_azimuth=self.xarm_azimuth,
+ yarm_azimuth=self.yarm_azimuth,
+ xarm_tilt=self.xarm_tilt,
+ yarm_tilt=self.yarm_tilt,
+ )
+ self.ifo_1.set_strain_data_from_frequency_domain_strain(
+ frequency_array=self.frequency_array, frequency_domain_strain=self.strain
+ )
+ self.ifo_2.set_strain_data_from_frequency_domain_strain(
+ frequency_array=self.frequency_array, frequency_domain_strain=self.strain
+ )
def tearDown(self):
del self.name
@@ -619,21 +748,23 @@ class TestInterferometerEquals(unittest.TestCase):
self.assertNotEqual(self.ifo_1, self.ifo_2)
def test_eq_false_different_ifo_strain_data(self):
- self.strain = bilby.utils.create_frequency_series(sampling_frequency=self.sampling_frequency / 2,
- duration=self.duration * 2)
- self.ifo_1.set_strain_data_from_frequency_domain_strain(frequency_array=self.frequency_array,
- frequency_domain_strain=self.strain)
+ self.strain = bilby.utils.create_frequency_series(
+ sampling_frequency=self.sampling_frequency / 2, duration=self.duration * 2
+ )
+ self.ifo_1.set_strain_data_from_frequency_domain_strain(
+ frequency_array=self.frequency_array, frequency_domain_strain=self.strain
+ )
self.assertNotEqual(self.ifo_1, self.ifo_2)
class TestInterferometerStrainData(unittest.TestCase):
-
def setUp(self):
self.minimum_frequency = 10
self.maximum_frequency = 20
self.ifosd = bilby.gw.detector.InterferometerStrainData(
minimum_frequency=self.minimum_frequency,
- maximum_frequency=self.maximum_frequency)
+ maximum_frequency=self.maximum_frequency,
+ )
def tearDown(self):
del self.minimum_frequency
@@ -643,64 +774,86 @@ class TestInterferometerStrainData(unittest.TestCase):
def test_frequency_mask(self):
self.minimum_frequency = 10
self.maximum_frequency = 20
- with mock.patch('bilby.core.utils.create_frequency_series') as m:
+ with mock.patch("bilby.core.utils.create_frequency_series") as m:
m.return_value = np.array([5, 15, 25])
self.ifosd.set_from_frequency_domain_strain(
- frequency_domain_strain=np.array([0, 1, 2]), frequency_array=np.array([5, 15, 25]))
- self.assertTrue(np.array_equal(self.ifosd.frequency_mask, [False, True, False]))
+ frequency_domain_strain=np.array([0, 1, 2]),
+ frequency_array=np.array([5, 15, 25]),
+ )
+ self.assertTrue(
+ np.array_equal(self.ifosd.frequency_mask, [False, True, False])
+ )
def test_set_data_fails(self):
- with mock.patch('bilby.core.utils.create_frequency_series') as m:
+ with mock.patch("bilby.core.utils.create_frequency_series") as m:
m.return_value = [1, 2, 3]
with self.assertRaises(ValueError):
self.ifosd.set_from_frequency_domain_strain(
- frequency_domain_strain=np.array([0, 1, 2]))
+ frequency_domain_strain=np.array([0, 1, 2])
+ )
def test_set_data_fails_too_much(self):
- with mock.patch('bilby.core.utils.create_frequency_series') as m:
+ with mock.patch("bilby.core.utils.create_frequency_series") as m:
m.return_value = [1, 2, 3]
with self.assertRaises(ValueError):
self.ifosd.set_from_frequency_domain_strain(
- frequency_domain_strain=np.array([0, 1, 2]), frequency_array=np.array([1, 2, 3]),
- duration=3, sampling_frequency=1)
+ frequency_domain_strain=np.array([0, 1, 2]),
+ frequency_array=np.array([1, 2, 3]),
+ duration=3,
+ sampling_frequency=1,
+ )
def test_start_time_init(self):
- with mock.patch('bilby.core.utils.create_frequency_series') as m:
+ with mock.patch("bilby.core.utils.create_frequency_series") as m:
m.return_value = [1, 2, 3]
duration = 3
sampling_frequency = 1
self.ifosd.set_from_frequency_domain_strain(
- frequency_domain_strain=np.array([0, 1, 2]), duration=duration,
- sampling_frequency=sampling_frequency)
+ frequency_domain_strain=np.array([0, 1, 2]),
+ duration=duration,
+ sampling_frequency=sampling_frequency,
+ )
self.assertTrue(self.ifosd.start_time == 0)
def test_start_time_set(self):
- with mock.patch('bilby.core.utils.create_frequency_series') as m:
+ with mock.patch("bilby.core.utils.create_frequency_series") as m:
m.return_value = [1, 2, 3]
duration = 3
sampling_frequency = 1
self.ifosd.set_from_frequency_domain_strain(
- frequency_domain_strain=np.array([0, 1, 2]), duration=duration,
- sampling_frequency=sampling_frequency, start_time=10)
+ frequency_domain_strain=np.array([0, 1, 2]),
+ duration=duration,
+ sampling_frequency=sampling_frequency,
+ start_time=10,
+ )
self.assertTrue(self.ifosd.start_time == 10)
def test_time_array_frequency_array_consistency(self):
duration = 1
sampling_frequency = 10
time_array = bilby.core.utils.create_time_series(
- sampling_frequency=sampling_frequency, duration=duration)
+ sampling_frequency=sampling_frequency, duration=duration
+ )
time_domain_strain = np.random.normal(
- 0, duration - 1 / sampling_frequency, len(time_array))
+ 0, duration - 1 / sampling_frequency, len(time_array)
+ )
self.ifosd.roll_off = 0
self.ifosd.set_from_time_domain_strain(
- time_domain_strain=time_domain_strain, duration=duration,
- sampling_frequency=sampling_frequency)
+ time_domain_strain=time_domain_strain,
+ duration=duration,
+ sampling_frequency=sampling_frequency,
+ )
frequency_domain_strain, freqs = bilby.core.utils.nfft(
- time_domain_strain, sampling_frequency)
+ time_domain_strain, sampling_frequency
+ )
- self.assertTrue(np.all(
- self.ifosd.frequency_domain_strain == frequency_domain_strain * self.ifosd.frequency_mask))
+ self.assertTrue(
+ np.all(
+ self.ifosd.frequency_domain_strain
+ == frequency_domain_strain * self.ifosd.frequency_mask
+ )
+ )
def test_time_within_data_before(self):
self.ifosd.start_time = 3
@@ -723,9 +876,10 @@ class TestInterferometerStrainData(unittest.TestCase):
self.ifosd._time_domain_strain = np.array([3])
self.ifosd.duration = 5
self.ifosd.roll_off = 2
- expected_window = scipy.signal.windows.tukey(len(self.ifosd._time_domain_strain), alpha=self.ifosd.alpha)
- self.assertEqual(expected_window,
- self.ifosd.time_domain_window())
+ expected_window = scipy.signal.windows.tukey(
+ len(self.ifosd._time_domain_strain), alpha=self.ifosd.alpha
+ )
+ self.assertEqual(expected_window, self.ifosd.time_domain_window())
self.assertEqual(np.mean(expected_window ** 2), self.ifosd.window_factor)
def test_time_domain_window_sets_roll_off_directly(self):
@@ -750,7 +904,7 @@ class TestInterferometerStrainData(unittest.TestCase):
self.ifosd._time_domain_strain = expected_strain
self.assertEqual(expected_strain, self.ifosd.time_domain_strain)
- @patch('bilby.core.utils.infft')
+ @patch("bilby.core.utils.infft")
def test_time_domain_strain_from_frequency_domain_strain(self, m):
m.return_value = 5
self.ifosd.sampling_frequency = 200
@@ -763,38 +917,47 @@ class TestInterferometerStrainData(unittest.TestCase):
self.ifosd._time_domain_strain = None
self.ifosd._frequency_domain_strain = None
with self.assertRaises(ValueError):
- test = self.ifosd.time_domain_strain
+ _ = self.ifosd.time_domain_strain
def test_frequency_domain_strain_when_set(self):
self.ifosd.sampling_frequency = 200
self.ifosd.duration = 4
expected_strain = self.ifosd.frequency_array * self.ifosd.frequency_mask
self.ifosd._frequency_domain_strain = expected_strain
- self.assertTrue(np.array_equal(expected_strain,
- self.ifosd.frequency_domain_strain))
+ self.assertTrue(
+ np.array_equal(expected_strain, self.ifosd.frequency_domain_strain)
+ )
- @patch('bilby.core.utils.nfft')
+ @patch("bilby.core.utils.nfft")
def test_frequency_domain_strain_from_frequency_domain_strain(self, m):
self.ifosd.start_time = 0
self.ifosd.duration = 4
self.ifosd.sampling_frequency = 200
m.return_value = self.ifosd.frequency_array, self.ifosd.frequency_array
self.ifosd._time_domain_strain = self.ifosd.time_array
- self.assertTrue(np.array_equal(self.ifosd.frequency_array * self.ifosd.frequency_mask,
- self.ifosd.frequency_domain_strain))
+ self.assertTrue(
+ np.array_equal(
+ self.ifosd.frequency_array * self.ifosd.frequency_mask,
+ self.ifosd.frequency_domain_strain,
+ )
+ )
def test_frequency_domain_strain_not_set(self):
self.ifosd._time_domain_strain = None
self.ifosd._frequency_domain_strain = None
with self.assertRaises(ValueError):
- test = self.ifosd.frequency_domain_strain
+ _ = self.ifosd.frequency_domain_strain
def test_set_frequency_domain_strain(self):
self.ifosd.duration = 4
self.ifosd.sampling_frequency = 200
self.ifosd.frequency_domain_strain = np.ones(len(self.ifosd.frequency_array))
- self.assertTrue(np.array_equal(np.ones(len(self.ifosd.frequency_array)),
- self.ifosd._frequency_domain_strain))
+ self.assertTrue(
+ np.array_equal(
+ np.ones(len(self.ifosd.frequency_array)),
+ self.ifosd._frequency_domain_strain,
+ )
+ )
def test_set_frequency_domain_strain_wrong_length(self):
self.ifosd.duration = 4
@@ -804,26 +967,32 @@ class TestInterferometerStrainData(unittest.TestCase):
class TestInterferometerStrainDataEquals(unittest.TestCase):
-
def setUp(self):
self.minimum_frequency = 10
self.maximum_frequency = 20
self.roll_off = 0.2
self.sampling_frequency = 100
self.duration = 2
- self.frequency_array = bilby.utils.create_frequency_series(sampling_frequency=self.sampling_frequency,
- duration=self.duration)
+ self.frequency_array = bilby.utils.create_frequency_series(
+ sampling_frequency=self.sampling_frequency, duration=self.duration
+ )
self.strain = self.frequency_array
- self.ifosd_1 = bilby.gw.detector.InterferometerStrainData(minimum_frequency=self.minimum_frequency,
- maximum_frequency=self.maximum_frequency,
- roll_off=self.roll_off)
- self.ifosd_2 = bilby.gw.detector.InterferometerStrainData(minimum_frequency=self.minimum_frequency,
- maximum_frequency=self.maximum_frequency,
- roll_off=self.roll_off)
- self.ifosd_1.set_from_frequency_domain_strain(frequency_domain_strain=self.strain,
- frequency_array=self.frequency_array)
- self.ifosd_2.set_from_frequency_domain_strain(frequency_domain_strain=self.strain,
- frequency_array=self.frequency_array)
+ self.ifosd_1 = bilby.gw.detector.InterferometerStrainData(
+ minimum_frequency=self.minimum_frequency,
+ maximum_frequency=self.maximum_frequency,
+ roll_off=self.roll_off,
+ )
+ self.ifosd_2 = bilby.gw.detector.InterferometerStrainData(
+ minimum_frequency=self.minimum_frequency,
+ maximum_frequency=self.maximum_frequency,
+ roll_off=self.roll_off,
+ )
+ self.ifosd_1.set_from_frequency_domain_strain(
+ frequency_domain_strain=self.strain, frequency_array=self.frequency_array
+ )
+ self.ifosd_2.set_from_frequency_domain_strain(
+ frequency_domain_strain=self.strain, frequency_array=self.frequency_array
+ )
def tearDown(self):
del self.minimum_frequency
@@ -868,38 +1037,45 @@ class TestInterferometerStrainDataEquals(unittest.TestCase):
self.assertNotEqual(self.ifosd_1, self.ifosd_2)
def test_eq_different_frequency_array(self):
- new_frequency_array = bilby.utils.create_frequency_series(sampling_frequency=self.sampling_frequency / 2,
- duration=self.duration * 2)
+ new_frequency_array = bilby.utils.create_frequency_series(
+ sampling_frequency=self.sampling_frequency / 2, duration=self.duration * 2
+ )
self.ifosd_1.frequency_array = new_frequency_array
self.assertNotEqual(self.ifosd_1, self.ifosd_2)
def test_eq_different_frequency_domain_strain(self):
- new_strain = bilby.utils.create_frequency_series(sampling_frequency=self.sampling_frequency / 2,
- duration=self.duration * 2)
+ new_strain = bilby.utils.create_frequency_series(
+ sampling_frequency=self.sampling_frequency / 2, duration=self.duration * 2
+ )
self.ifosd_1._frequency_domain_strain = new_strain
self.assertNotEqual(self.ifosd_1, self.ifosd_2)
def test_eq_different_time_array(self):
- new_time_array = bilby.utils.create_time_series(sampling_frequency=self.sampling_frequency / 2,
- duration=self.duration * 2)
+ new_time_array = bilby.utils.create_time_series(
+ sampling_frequency=self.sampling_frequency / 2, duration=self.duration * 2
+ )
self.ifosd_1.time_array = new_time_array
self.assertNotEqual(self.ifosd_1, self.ifosd_2)
def test_eq_different_time_domain_strain(self):
- new_strain = bilby.utils.create_time_series(sampling_frequency=self.sampling_frequency / 2,
- duration=self.duration * 2)
+ new_strain = bilby.utils.create_time_series(
+ sampling_frequency=self.sampling_frequency / 2, duration=self.duration * 2
+ )
self.ifosd_1._time_domain_strain = new_strain
self.assertNotEqual(self.ifosd_1, self.ifosd_2)
class TestInterferometerList(unittest.TestCase):
-
def setUp(self):
self.frequency_arrays = np.linspace(0, 4096, 4097)
- self.name1 = 'name1'
- self.name2 = 'name2'
- self.power_spectral_density1 = bilby.gw.detector.PowerSpectralDensity.from_aligo()
- self.power_spectral_density2 = bilby.gw.detector.PowerSpectralDensity.from_aligo()
+ self.name1 = "name1"
+ self.name2 = "name2"
+ self.power_spectral_density1 = (
+ bilby.gw.detector.PowerSpectralDensity.from_aligo()
+ )
+ self.power_spectral_density2 = (
+ bilby.gw.detector.PowerSpectralDensity.from_aligo()
+ )
self.minimum_frequency1 = 10
self.minimum_frequency2 = 10
self.maximum_frequency1 = 20
@@ -916,33 +1092,47 @@ class TestInterferometerList(unittest.TestCase):
self.xarm_azimuth2 = 4
self.yarm_azimuth1 = 5
self.yarm_azimuth2 = 5
- self.xarm_tilt1 = 0.
- self.xarm_tilt2 = 0.
- self.yarm_tilt1 = 0.
- self.yarm_tilt2 = 0.
+ self.xarm_tilt1 = 0.0
+ self.xarm_tilt2 = 0.0
+ self.yarm_tilt1 = 0.0
+ self.yarm_tilt2 = 0.0
# noinspection PyTypeChecker
- self.ifo1 = bilby.gw.detector.Interferometer(name=self.name1,
- power_spectral_density=self.power_spectral_density1,
- minimum_frequency=self.minimum_frequency1,
- maximum_frequency=self.maximum_frequency1, length=self.length1,
- latitude=self.latitude1, longitude=self.longitude1,
- elevation=self.elevation1,
- xarm_azimuth=self.xarm_azimuth1, yarm_azimuth=self.yarm_azimuth1,
- xarm_tilt=self.xarm_tilt1, yarm_tilt=self.yarm_tilt1)
- self.ifo2 = bilby.gw.detector.Interferometer(name=self.name2,
- power_spectral_density=self.power_spectral_density2,
- minimum_frequency=self.minimum_frequency2,
- maximum_frequency=self.maximum_frequency2, length=self.length2,
- latitude=self.latitude2, longitude=self.longitude2,
- elevation=self.elevation2,
- xarm_azimuth=self.xarm_azimuth2, yarm_azimuth=self.yarm_azimuth2,
- xarm_tilt=self.xarm_tilt2, yarm_tilt=self.yarm_tilt2)
+ self.ifo1 = bilby.gw.detector.Interferometer(
+ name=self.name1,
+ power_spectral_density=self.power_spectral_density1,
+ minimum_frequency=self.minimum_frequency1,
+ maximum_frequency=self.maximum_frequency1,
+ length=self.length1,
+ latitude=self.latitude1,
+ longitude=self.longitude1,
+ elevation=self.elevation1,
+ xarm_azimuth=self.xarm_azimuth1,
+ yarm_azimuth=self.yarm_azimuth1,
+ xarm_tilt=self.xarm_tilt1,
+ yarm_tilt=self.yarm_tilt1,
+ )
+ self.ifo2 = bilby.gw.detector.Interferometer(
+ name=self.name2,
+ power_spectral_density=self.power_spectral_density2,
+ minimum_frequency=self.minimum_frequency2,
+ maximum_frequency=self.maximum_frequency2,
+ length=self.length2,
+ latitude=self.latitude2,
+ longitude=self.longitude2,
+ elevation=self.elevation2,
+ xarm_azimuth=self.xarm_azimuth2,
+ yarm_azimuth=self.yarm_azimuth2,
+ xarm_tilt=self.xarm_tilt2,
+ yarm_tilt=self.yarm_tilt2,
+ )
self.ifo1.strain_data.set_from_frequency_domain_strain(
- self.frequency_arrays, sampling_frequency=4096, duration=2)
+ self.frequency_arrays, sampling_frequency=4096, duration=2
+ )
self.ifo2.strain_data.set_from_frequency_domain_strain(
- self.frequency_arrays, sampling_frequency=4096, duration=2)
+ self.frequency_arrays, sampling_frequency=4096, duration=2
+ )
self.ifo_list = bilby.gw.detector.InterferometerList([self.ifo1, self.ifo2])
- self.outdir = 'outdir'
+ self.outdir = "outdir"
bilby.core.utils.check_directory_exists_and_if_not_mkdir(self.outdir)
def tearDown(self):
@@ -982,10 +1172,10 @@ class TestInterferometerList(unittest.TestCase):
def test_init_with_string_list(self):
""" Merely checks if this ends up in the right bracket """
- with mock.patch('bilby.gw.detector.networks.get_empty_interferometer') as m:
+ with mock.patch("bilby.gw.detector.networks.get_empty_interferometer") as m:
m.side_effect = TypeError
with self.assertRaises(TypeError):
- bilby.gw.detector.InterferometerList(['string'])
+ bilby.gw.detector.InterferometerList(["string"])
def test_init_with_other_object(self):
with self.assertRaises(TypeError):
@@ -998,31 +1188,45 @@ class TestInterferometerList(unittest.TestCase):
def test_init_inconsistent_duration(self):
self.frequency_arrays = np.linspace(0, 2048, 2049)
- self.ifo2 = bilby.gw.detector.Interferometer(name=self.name2,
- power_spectral_density=self.power_spectral_density2,
- minimum_frequency=self.minimum_frequency2,
- maximum_frequency=self.maximum_frequency2, length=self.length2,
- latitude=self.latitude2, longitude=self.longitude2,
- elevation=self.elevation2,
- xarm_azimuth=self.xarm_azimuth2, yarm_azimuth=self.yarm_azimuth2,
- xarm_tilt=self.xarm_tilt2, yarm_tilt=self.yarm_tilt2)
+ self.ifo2 = bilby.gw.detector.Interferometer(
+ name=self.name2,
+ power_spectral_density=self.power_spectral_density2,
+ minimum_frequency=self.minimum_frequency2,
+ maximum_frequency=self.maximum_frequency2,
+ length=self.length2,
+ latitude=self.latitude2,
+ longitude=self.longitude2,
+ elevation=self.elevation2,
+ xarm_azimuth=self.xarm_azimuth2,
+ yarm_azimuth=self.yarm_azimuth2,
+ xarm_tilt=self.xarm_tilt2,
+ yarm_tilt=self.yarm_tilt2,
+ )
self.ifo2.strain_data.set_from_frequency_domain_strain(
- self.frequency_arrays, sampling_frequency=4096, duration=1)
+ self.frequency_arrays, sampling_frequency=4096, duration=1
+ )
with self.assertRaises(ValueError):
bilby.gw.detector.InterferometerList([self.ifo1, self.ifo2])
def test_init_inconsistent_sampling_frequency(self):
self.frequency_arrays = np.linspace(0, 2048, 2049)
- self.ifo2 = bilby.gw.detector.Interferometer(name=self.name2,
- power_spectral_density=self.power_spectral_density2,
- minimum_frequency=self.minimum_frequency2,
- maximum_frequency=self.maximum_frequency2, length=self.length2,
- latitude=self.latitude2, longitude=self.longitude2,
- elevation=self.elevation2,
- xarm_azimuth=self.xarm_azimuth2, yarm_azimuth=self.yarm_azimuth2,
- xarm_tilt=self.xarm_tilt2, yarm_tilt=self.yarm_tilt2)
+ self.ifo2 = bilby.gw.detector.Interferometer(
+ name=self.name2,
+ power_spectral_density=self.power_spectral_density2,
+ minimum_frequency=self.minimum_frequency2,
+ maximum_frequency=self.maximum_frequency2,
+ length=self.length2,
+ latitude=self.latitude2,
+ longitude=self.longitude2,
+ elevation=self.elevation2,
+ xarm_azimuth=self.xarm_azimuth2,
+ yarm_azimuth=self.yarm_azimuth2,
+ xarm_tilt=self.xarm_tilt2,
+ yarm_tilt=self.yarm_tilt2,
+ )
self.ifo2.strain_data.set_from_frequency_domain_strain(
- self.frequency_arrays, sampling_frequency=2048, duration=2)
+ self.frequency_arrays, sampling_frequency=2048, duration=2
+ )
with self.assertRaises(ValueError):
bilby.gw.detector.InterferometerList([self.ifo1, self.ifo2])
@@ -1031,7 +1235,7 @@ class TestInterferometerList(unittest.TestCase):
with self.assertRaises(ValueError):
bilby.gw.detector.InterferometerList([self.ifo1, self.ifo2])
- @patch.object(bilby.gw.detector.networks.logger, 'warning')
+ @patch.object(bilby.gw.detector.networks.logger, "warning")
def test_check_interferometers_relative_tolerance(self, mock_warning):
# Value larger than relative tolerance -- not tolerated
self.ifo2.strain_data.start_time = self.ifo1.strain_data.start_time + 1e-4
@@ -1045,18 +1249,25 @@ class TestInterferometerList(unittest.TestCase):
self.assertTrue(mock_warning.called)
warning_log_str = mock_warning.call_args.args[0].args[0]
self.assertIsInstance(warning_log_str, str)
- self.assertTrue("The start_time of all interferometers are not the same:" in
- warning_log_str)
+ self.assertTrue(
+ "The start_time of all interferometers are not the same:" in warning_log_str
+ )
- @patch.object(bilby.gw.detector.Interferometer, 'set_strain_data_from_power_spectral_density')
+ @patch.object(
+ bilby.gw.detector.Interferometer, "set_strain_data_from_power_spectral_density"
+ )
def test_set_strain_data_from_power_spectral_density(self, m):
- self.ifo_list.set_strain_data_from_power_spectral_densities(sampling_frequency=123, duration=6.2, start_time=3)
+ self.ifo_list.set_strain_data_from_power_spectral_densities(
+ sampling_frequency=123, duration=6.2, start_time=3
+ )
m.assert_called_with(sampling_frequency=123, duration=6.2, start_time=3)
self.assertEqual(len(self.ifo_list), m.call_count)
def test_inject_signal_pol_and_wg_none(self):
with self.assertRaises(ValueError):
- self.ifo_list.inject_signal(injection_polarizations=None, waveform_generator=None)
+ self.ifo_list.inject_signal(
+ injection_polarizations=None, waveform_generator=None
+ )
def test_meta_data(self):
ifos_list = [self.ifo1, self.ifo2]
@@ -1065,33 +1276,46 @@ class TestInterferometerList(unittest.TestCase):
meta_data = {ifo.name: ifo.meta_data for ifo in ifos_list}
self.assertEqual(ifos.meta_data, meta_data)
- @patch.object(bilby.gw.waveform_generator.WaveformGenerator, 'frequency_domain_strain')
+ @patch.object(
+ bilby.gw.waveform_generator.WaveformGenerator, "frequency_domain_strain"
+ )
def test_inject_signal_pol_none_calls_frequency_domain_strain(self, m):
waveform_generator = bilby.gw.waveform_generator.WaveformGenerator(
- frequency_domain_source_model=lambda x, y, z: x)
+ frequency_domain_source_model=lambda x, y, z: x
+ )
self.ifo1.inject_signal = MagicMock(return_value=None)
self.ifo2.inject_signal = MagicMock(return_value=None)
- self.ifo_list.inject_signal(parameters=None, waveform_generator=waveform_generator)
+ self.ifo_list.inject_signal(
+ parameters=None, waveform_generator=waveform_generator
+ )
self.assertTrue(m.called)
- @patch.object(bilby.gw.detector.Interferometer, 'inject_signal')
+ @patch.object(bilby.gw.detector.Interferometer, "inject_signal")
def test_inject_signal_with_inj_pol(self, m):
self.ifo_list.inject_signal(injection_polarizations=dict(plus=1))
m.assert_called_with(parameters=None, injection_polarizations=dict(plus=1))
self.assertEqual(len(self.ifo_list), m.call_count)
- @patch.object(bilby.gw.detector.Interferometer, 'inject_signal')
+ @patch.object(bilby.gw.detector.Interferometer, "inject_signal")
def test_inject_signal_returns_expected_polarisations(self, m):
m.return_value = dict(plus=1, cross=2)
injection_polarizations = dict(plus=1, cross=2)
- ifos_pol = self.ifo_list.inject_signal(injection_polarizations=injection_polarizations)
- self.assertDictEqual(self.ifo1.inject_signal(injection_polarizations=injection_polarizations), ifos_pol[0])
- self.assertDictEqual(self.ifo2.inject_signal(injection_polarizations=injection_polarizations), ifos_pol[1])
-
- @patch.object(bilby.gw.detector.Interferometer, 'save_data')
+ ifos_pol = self.ifo_list.inject_signal(
+ injection_polarizations=injection_polarizations
+ )
+ self.assertDictEqual(
+ self.ifo1.inject_signal(injection_polarizations=injection_polarizations),
+ ifos_pol[0],
+ )
+ self.assertDictEqual(
+ self.ifo2.inject_signal(injection_polarizations=injection_polarizations),
+ ifos_pol[1],
+ )
+
+ @patch.object(bilby.gw.detector.Interferometer, "save_data")
def test_save_data(self, m):
- self.ifo_list.save_data(outdir='test_outdir', label='test_outdir')
- m.assert_called_with(outdir='test_outdir', label='test_outdir')
+ self.ifo_list.save_data(outdir="test_outdir", label="test_outdir")
+ m.assert_called_with(outdir="test_outdir", label="test_outdir")
self.assertEqual(len(self.ifo_list), m.call_count)
def test_number_of_interferometers(self):
@@ -1102,16 +1326,28 @@ class TestInterferometerList(unittest.TestCase):
self.assertEqual(self.ifo2.strain_data.duration, self.ifo_list.duration)
def test_sampling_frequency(self):
- self.assertEqual(self.ifo1.strain_data.sampling_frequency, self.ifo_list.sampling_frequency)
- self.assertEqual(self.ifo2.strain_data.sampling_frequency, self.ifo_list.sampling_frequency)
+ self.assertEqual(
+ self.ifo1.strain_data.sampling_frequency, self.ifo_list.sampling_frequency
+ )
+ self.assertEqual(
+ self.ifo2.strain_data.sampling_frequency, self.ifo_list.sampling_frequency
+ )
def test_start_time(self):
self.assertEqual(self.ifo1.strain_data.start_time, self.ifo_list.start_time)
self.assertEqual(self.ifo2.strain_data.start_time, self.ifo_list.start_time)
def test_frequency_array(self):
- self.assertTrue(np.array_equal(self.ifo1.strain_data.frequency_array, self.ifo_list.frequency_array))
- self.assertTrue(np.array_equal(self.ifo2.strain_data.frequency_array, self.ifo_list.frequency_array))
+ self.assertTrue(
+ np.array_equal(
+ self.ifo1.strain_data.frequency_array, self.ifo_list.frequency_array
+ )
+ )
+ self.assertTrue(
+ np.array_equal(
+ self.ifo2.strain_data.frequency_array, self.ifo_list.frequency_array
+ )
+ )
def test_append_with_ifo(self):
self.ifo_list.append(self.ifo2)
@@ -1121,16 +1357,20 @@ class TestInterferometerList(unittest.TestCase):
def test_append_with_ifo_list(self):
self.ifo_list.append(self.ifo_list)
names = [ifo.name for ifo in self.ifo_list]
- self.assertListEqual([self.ifo1.name, self.ifo2.name, self.ifo1.name, self.ifo2.name], names)
+ self.assertListEqual(
+ [self.ifo1.name, self.ifo2.name, self.ifo1.name, self.ifo2.name], names
+ )
def test_extend(self):
self.ifo_list.extend(self.ifo_list)
names = [ifo.name for ifo in self.ifo_list]
- self.assertListEqual([self.ifo1.name, self.ifo2.name, self.ifo1.name, self.ifo2.name], names)
+ self.assertListEqual(
+ [self.ifo1.name, self.ifo2.name, self.ifo1.name, self.ifo2.name], names
+ )
def test_insert(self):
new_ifo = self.ifo1
- new_ifo.name = 'name3'
+ new_ifo.name = "name3"
self.ifo_list.insert(1, new_ifo)
names = [ifo.name for ifo in self.ifo_list]
self.assertListEqual([self.ifo1.name, new_ifo.name, self.ifo2.name], names)
@@ -1138,10 +1378,10 @@ class TestInterferometerList(unittest.TestCase):
def test_to_and_from_hdf5_loading(self):
if sys.version_info[0] < 3:
with self.assertRaises(NotImplementedError):
- self.ifo_list.to_hdf5(outdir='outdir', label='test')
+ self.ifo_list.to_hdf5(outdir="outdir", label="test")
else:
- self.ifo_list.to_hdf5(outdir='outdir', label='test')
- filename = 'outdir/test_name1name2.h5'
+ self.ifo_list.to_hdf5(outdir="outdir", label="test")
+ filename = "outdir/test_name1name2.h5"
recovered_ifo = bilby.gw.detector.InterferometerList.from_hdf5(filename)
self.assertListEqual(self.ifo_list, recovered_ifo)
@@ -1149,28 +1389,28 @@ class TestInterferometerList(unittest.TestCase):
if sys.version_info[0] < 3:
pass
else:
- dd.io.save('./outdir/psd.h5', self.ifo_list[0].power_spectral_density)
+ dd.io.save("./outdir/psd.h5", self.ifo_list[0].power_spectral_density)
filename = self.ifo_list._hdf5_filename_from_outdir_label(
- outdir='outdir', label='psd')
+ outdir="outdir", label="psd"
+ )
with self.assertRaises(TypeError):
bilby.gw.detector.InterferometerList.from_hdf5(filename)
def test_plot_data(self):
- ifos = bilby.gw.detector.InterferometerList(['H1', 'L1'])
+ ifos = bilby.gw.detector.InterferometerList(["H1", "L1"])
ifos.set_strain_data_from_power_spectral_densities(2048, 4)
ifos.plot_data(outdir=self.outdir)
- ifos = bilby.gw.detector.InterferometerList(['H1', 'L1', 'V1'])
+ ifos = bilby.gw.detector.InterferometerList(["H1", "L1", "V1"])
ifos.set_strain_data_from_power_spectral_densities(2048, 4)
ifos.plot_data(outdir=self.outdir)
class TestPowerSpectralDensityWithoutFiles(unittest.TestCase):
-
def setUp(self):
- self.frequency_array = np.array([1., 2., 3.])
- self.psd_array = np.array([16., 25., 36.])
- self.asd_array = np.array([4., 5., 6.])
+ self.frequency_array = np.array([1.0, 2.0, 3.0])
+ self.psd_array = np.array([16.0, 25.0, 36.0])
+ self.asd_array = np.array([4.0, 5.0, 6.0])
def tearDown(self):
del self.frequency_array
@@ -1178,72 +1418,91 @@ class TestPowerSpectralDensityWithoutFiles(unittest.TestCase):
del self.asd_array
def test_init_with_asd_array(self):
- psd = bilby.gw.detector.PowerSpectralDensity(frequency_array=self.frequency_array, asd_array=self.asd_array)
+ psd = bilby.gw.detector.PowerSpectralDensity(
+ frequency_array=self.frequency_array, asd_array=self.asd_array
+ )
self.assertTrue(np.array_equal(self.frequency_array, psd.frequency_array))
self.assertTrue(np.array_equal(self.asd_array, psd.asd_array))
self.assertTrue(np.array_equal(self.psd_array, psd.psd_array))
def test_init_with_psd_array(self):
- psd = bilby.gw.detector.PowerSpectralDensity(frequency_array=self.frequency_array, psd_array=self.psd_array)
+ psd = bilby.gw.detector.PowerSpectralDensity(
+ frequency_array=self.frequency_array, psd_array=self.psd_array
+ )
self.assertTrue(np.array_equal(self.frequency_array, psd.frequency_array))
self.assertTrue(np.array_equal(self.asd_array, psd.asd_array))
self.assertTrue(np.array_equal(self.psd_array, psd.psd_array))
def test_setting_asd_array_after_init(self):
- psd = bilby.gw.detector.PowerSpectralDensity(frequency_array=self.frequency_array)
+ psd = bilby.gw.detector.PowerSpectralDensity(
+ frequency_array=self.frequency_array
+ )
psd.asd_array = self.asd_array
self.assertTrue(np.array_equal(self.frequency_array, psd.frequency_array))
self.assertTrue(np.array_equal(self.asd_array, psd.asd_array))
self.assertTrue(np.array_equal(self.psd_array, psd.psd_array))
def test_setting_psd_array_after_init(self):
- psd = bilby.gw.detector.PowerSpectralDensity(frequency_array=self.frequency_array)
+ psd = bilby.gw.detector.PowerSpectralDensity(
+ frequency_array=self.frequency_array
+ )
psd.psd_array = self.psd_array
self.assertTrue(np.array_equal(self.frequency_array, psd.frequency_array))
self.assertTrue(np.array_equal(self.asd_array, psd.asd_array))
self.assertTrue(np.array_equal(self.psd_array, psd.psd_array))
def test_power_spectral_density_interpolated_from_asd_array(self):
- expected = np.array([25.])
- psd = bilby.gw.detector.PowerSpectralDensity(frequency_array=self.frequency_array, asd_array=self.asd_array)
+ expected = np.array([25.0])
+ psd = bilby.gw.detector.PowerSpectralDensity(
+ frequency_array=self.frequency_array, asd_array=self.asd_array
+ )
self.assertEqual(expected, psd.power_spectral_density_interpolated(2))
def test_power_spectral_density_interpolated_from_psd_array(self):
- expected = np.array([25.])
- psd = bilby.gw.detector.PowerSpectralDensity(frequency_array=self.frequency_array, psd_array=self.psd_array)
+ expected = np.array([25.0])
+ psd = bilby.gw.detector.PowerSpectralDensity(
+ frequency_array=self.frequency_array, psd_array=self.psd_array
+ )
self.assertEqual(expected, psd.power_spectral_density_interpolated(2))
def test_from_amplitude_spectral_density_array(self):
actual = bilby.gw.detector.PowerSpectralDensity.from_amplitude_spectral_density_array(
- frequency_array=self.frequency_array, asd_array=self.asd_array)
+ frequency_array=self.frequency_array, asd_array=self.asd_array
+ )
self.assertTrue(np.array_equal(self.psd_array, actual.psd_array))
self.assertTrue(np.array_equal(self.asd_array, actual.asd_array))
def test_from_power_spectral_density_array(self):
actual = bilby.gw.detector.PowerSpectralDensity.from_power_spectral_density_array(
- frequency_array=self.frequency_array, psd_array=self.psd_array)
+ frequency_array=self.frequency_array, psd_array=self.psd_array
+ )
self.assertTrue(np.array_equal(self.psd_array, actual.psd_array))
self.assertTrue(np.array_equal(self.asd_array, actual.asd_array))
def test_repr(self):
- psd = bilby.gw.detector.PowerSpectralDensity(frequency_array=self.frequency_array, psd_array=self.psd_array)
- expected = 'PowerSpectralDensity(frequency_array={}, psd_array={}, asd_array={})'.format(self.frequency_array,
- self.psd_array,
- self.asd_array)
+ psd = bilby.gw.detector.PowerSpectralDensity(
+ frequency_array=self.frequency_array, psd_array=self.psd_array
+ )
+ expected = "PowerSpectralDensity(frequency_array={}, psd_array={}, asd_array={})".format(
+ self.frequency_array, self.psd_array, self.asd_array
+ )
self.assertEqual(expected, repr(psd))
class TestPowerSpectralDensityWithFiles(unittest.TestCase):
-
def setUp(self):
- self.dir = os.path.join(os.path.dirname(__file__), 'noise_curves')
+ self.dir = os.path.join(os.path.dirname(__file__), "noise_curves")
os.mkdir(self.dir)
- self.asd_file = os.path.join(os.path.dirname(__file__), 'noise_curves', 'asd_test_file.txt')
- self.psd_file = os.path.join(os.path.dirname(__file__), 'noise_curves', 'psd_test_file.txt')
- with open(self.asd_file, 'w') as f:
- f.write('1.\t1.0e-21\n2.\t2.0e-21\n3.\t3.0e-21')
- with open(self.psd_file, 'w') as f:
- f.write('1.\t1.0e-42\n2.\t4.0e-42\n3.\t9.0e-42')
+ self.asd_file = os.path.join(
+ os.path.dirname(__file__), "noise_curves", "asd_test_file.txt"
+ )
+ self.psd_file = os.path.join(
+ os.path.dirname(__file__), "noise_curves", "psd_test_file.txt"
+ )
+ with open(self.asd_file, "w") as f:
+ f.write("1.\t1.0e-21\n2.\t2.0e-21\n3.\t3.0e-21")
+ with open(self.psd_file, "w") as f:
+ f.write("1.\t1.0e-42\n2.\t4.0e-42\n3.\t9.0e-42")
self.frequency_array = np.array([1.0, 2.0, 3.0])
self.asd_array = np.array([1.0e-21, 2.0e-21, 3.0e-21])
self.psd_array = np.array([1.0e-42, 4.0e-42, 9.0e-42])
@@ -1259,26 +1518,34 @@ class TestPowerSpectralDensityWithFiles(unittest.TestCase):
del self.psd_file
def test_init_with_psd_file(self):
- psd = bilby.gw.detector.PowerSpectralDensity(frequency_array=self.frequency_array, psd_file=self.psd_file)
+ psd = bilby.gw.detector.PowerSpectralDensity(
+ frequency_array=self.frequency_array, psd_file=self.psd_file
+ )
self.assertEqual(self.psd_file, psd.psd_file)
self.assertTrue(np.array_equal(self.psd_array, psd.psd_array))
self.assertTrue(np.allclose(self.asd_array, psd.asd_array, atol=1e-30))
def test_init_with_asd_file(self):
- psd = bilby.gw.detector.PowerSpectralDensity(frequency_array=self.frequency_array, asd_file=self.asd_file)
+ psd = bilby.gw.detector.PowerSpectralDensity(
+ frequency_array=self.frequency_array, asd_file=self.asd_file
+ )
self.assertEqual(self.asd_file, psd.asd_file)
self.assertTrue(np.allclose(self.psd_array, psd.psd_array, atol=1e-60))
self.assertTrue(np.array_equal(self.asd_array, psd.asd_array))
def test_setting_psd_array_after_init(self):
- psd = bilby.gw.detector.PowerSpectralDensity(frequency_array=self.frequency_array)
+ psd = bilby.gw.detector.PowerSpectralDensity(
+ frequency_array=self.frequency_array
+ )
psd.psd_file = self.psd_file
self.assertEqual(self.psd_file, psd.psd_file)
self.assertTrue(np.array_equal(self.psd_array, psd.psd_array))
self.assertTrue(np.allclose(self.asd_array, psd.asd_array, atol=1e-30))
def test_init_with_asd_array_after_init(self):
- psd = bilby.gw.detector.PowerSpectralDensity(frequency_array=self.frequency_array)
+ psd = bilby.gw.detector.PowerSpectralDensity(
+ frequency_array=self.frequency_array
+ )
psd.asd_file = self.asd_file
self.assertEqual(self.asd_file, psd.asd_file)
self.assertTrue(np.allclose(self.psd_array, psd.psd_array, atol=1e-60))
@@ -1286,92 +1553,113 @@ class TestPowerSpectralDensityWithFiles(unittest.TestCase):
def test_power_spectral_density_interpolated_from_asd_file(self):
expected = np.array([4.0e-42])
- psd = bilby.gw.detector.PowerSpectralDensity(frequency_array=self.frequency_array, asd_file=self.asd_file)
- self.assertTrue(np.allclose(expected, psd.power_spectral_density_interpolated(2), atol=1e-60))
+ psd = bilby.gw.detector.PowerSpectralDensity(
+ frequency_array=self.frequency_array, asd_file=self.asd_file
+ )
+ self.assertTrue(
+ np.allclose(
+ expected, psd.power_spectral_density_interpolated(2), atol=1e-60
+ )
+ )
def test_power_spectral_density_interpolated_from_psd_file(self):
expected = np.array([4.0e-42])
- psd = bilby.gw.detector.PowerSpectralDensity(frequency_array=self.frequency_array, psd_file=self.psd_file)
+ psd = bilby.gw.detector.PowerSpectralDensity(
+ frequency_array=self.frequency_array, psd_file=self.psd_file
+ )
self.assertAlmostEqual(expected, psd.power_spectral_density_interpolated(2))
def test_from_amplitude_spectral_density_file(self):
- psd = bilby.gw.detector.PowerSpectralDensity.from_amplitude_spectral_density_file(asd_file=self.asd_file)
+ psd = bilby.gw.detector.PowerSpectralDensity.from_amplitude_spectral_density_file(
+ asd_file=self.asd_file
+ )
self.assertEqual(self.asd_file, psd.asd_file)
self.assertTrue(np.allclose(self.psd_array, psd.psd_array, atol=1e-60))
self.assertTrue(np.array_equal(self.asd_array, psd.asd_array))
def test_from_power_spectral_density_file(self):
- psd = bilby.gw.detector.PowerSpectralDensity.from_power_spectral_density_file(psd_file=self.psd_file)
+ psd = bilby.gw.detector.PowerSpectralDensity.from_power_spectral_density_file(
+ psd_file=self.psd_file
+ )
self.assertEqual(self.psd_file, psd.psd_file)
self.assertTrue(np.array_equal(self.psd_array, psd.psd_array))
self.assertTrue(np.allclose(self.asd_array, psd.asd_array, atol=1e-30))
def test_from_aligo(self):
psd = bilby.gw.detector.PowerSpectralDensity.from_aligo()
- expected_filename = 'aLIGO_ZERO_DET_high_P_psd.txt'
+ expected_filename = "aLIGO_ZERO_DET_high_P_psd.txt"
expected = bilby.gw.detector.PowerSpectralDensity(psd_file=expected_filename)
- actual_filename = psd.psd_file.split('/')[-1]
+ actual_filename = psd.psd_file.split("/")[-1]
self.assertEqual(expected_filename, actual_filename)
self.assertTrue(np.allclose(expected.psd_array, psd.psd_array, atol=1e-60))
self.assertTrue(np.array_equal(expected.asd_array, psd.asd_array))
def test_check_file_psd_file_set_to_asd_file(self):
- logger = logging.getLogger('bilby')
+ logger = logging.getLogger("bilby")
m = MagicMock()
logger.warning = m
- psd = bilby.gw.detector.PowerSpectralDensity(psd_file=self.asd_file)
+ _ = bilby.gw.detector.PowerSpectralDensity(psd_file=self.asd_file)
self.assertEqual(4, m.call_count)
def test_check_file_not_called_psd_file_set_to_psd_file(self):
- logger = logging.getLogger('bilby')
+ logger = logging.getLogger("bilby")
m = MagicMock()
logger.warning = m
- psd = bilby.gw.detector.PowerSpectralDensity(psd_file=self.psd_file)
+ _ = bilby.gw.detector.PowerSpectralDensity(psd_file=self.psd_file)
self.assertEqual(0, m.call_count)
def test_check_file_asd_file_set_to_psd_file(self):
- logger = logging.getLogger('bilby')
+ logger = logging.getLogger("bilby")
m = MagicMock()
logger.warning = m
- psd = bilby.gw.detector.PowerSpectralDensity(asd_file=self.psd_file)
+ _ = bilby.gw.detector.PowerSpectralDensity(asd_file=self.psd_file)
self.assertEqual(4, m.call_count)
def test_check_file_not_called_asd_file_set_to_asd_file(self):
- logger = logging.getLogger('bilby')
+ logger = logging.getLogger("bilby")
m = MagicMock()
logger.warning = m
- psd = bilby.gw.detector.PowerSpectralDensity(asd_file=self.asd_file)
+ _ = bilby.gw.detector.PowerSpectralDensity(asd_file=self.asd_file)
self.assertEqual(0, m.call_count)
def test_from_frame_file(self):
- expected_frequency_array = np.array([1., 2., 3.])
- expected_psd_array = np.array([16., 25., 36.])
- with mock.patch('bilby.gw.detector.InterferometerStrainData.set_from_frame_file') as m:
- with mock.patch('bilby.gw.detector.InterferometerStrainData.create_power_spectral_density') as n:
+ expected_frequency_array = np.array([1.0, 2.0, 3.0])
+ expected_psd_array = np.array([16.0, 25.0, 36.0])
+ with mock.patch(
+ "bilby.gw.detector.InterferometerStrainData.set_from_frame_file"
+ ) as _:
+ with mock.patch(
+ "bilby.gw.detector.InterferometerStrainData.create_power_spectral_density"
+ ) as n:
n.return_value = expected_frequency_array, expected_psd_array
- psd = bilby.gw.detector.PowerSpectralDensity.from_frame_file(frame_file=self.asd_file,
- psd_start_time=0,
- psd_duration=4)
- self.assertTrue(np.array_equal(expected_frequency_array, psd.frequency_array))
+ psd = bilby.gw.detector.PowerSpectralDensity.from_frame_file(
+ frame_file=self.asd_file, psd_start_time=0, psd_duration=4
+ )
+ self.assertTrue(
+ np.array_equal(expected_frequency_array, psd.frequency_array)
+ )
self.assertTrue(np.array_equal(expected_psd_array, psd.psd_array))
def test_repr(self):
psd = bilby.gw.detector.PowerSpectralDensity(psd_file=self.psd_file)
- expected = 'PowerSpectralDensity(psd_file=\'{}\', asd_file=\'{}\')'.format(self.psd_file, None)
+ expected = "PowerSpectralDensity(psd_file='{}', asd_file='{}')".format(
+ self.psd_file, None
+ )
self.assertEqual(expected, repr(psd))
class TestPowerSpectralDensityEquals(unittest.TestCase):
-
def setUp(self):
self.psd_from_file_1 = bilby.gw.detector.PowerSpectralDensity.from_aligo()
self.psd_from_file_2 = bilby.gw.detector.PowerSpectralDensity.from_aligo()
self.frequency_array = np.linspace(1, 100)
self.psd_array = np.linspace(1, 100)
- self.psd_from_array_1 = bilby.gw.detector.PowerSpectralDensity. \
- from_power_spectral_density_array(frequency_array=self.frequency_array, psd_array=self.psd_array)
- self.psd_from_array_2 = bilby.gw.detector.PowerSpectralDensity. \
- from_power_spectral_density_array(frequency_array=self.frequency_array, psd_array=self.psd_array)
+ self.psd_from_array_1 = bilby.gw.detector.PowerSpectralDensity.from_power_spectral_density_array(
+ frequency_array=self.frequency_array, psd_array=self.psd_array
+ )
+ self.psd_from_array_2 = bilby.gw.detector.PowerSpectralDensity.from_power_spectral_density_array(
+ frequency_array=self.frequency_array, psd_array=self.psd_array
+ )
def tearDown(self):
del self.psd_from_file_1
@@ -1388,14 +1676,14 @@ class TestPowerSpectralDensityEquals(unittest.TestCase):
self.assertEqual(self.psd_from_file_1, self.psd_from_file_2)
def test_eq_false_different_psd_file_name(self):
- self.psd_from_file_1._psd_file = 'some_other_name'
+ self.psd_from_file_1._psd_file = "some_other_name"
self.assertNotEqual(self.psd_from_file_1, self.psd_from_file_2)
def test_eq_false_different_asd_file_name(self):
self.psd_from_file_1._psd_file = None
self.psd_from_file_2._psd_file = None
- self.psd_from_file_1._asd_file = 'some_name'
- self.psd_from_file_2._asd_file = 'some_other_name'
+ self.psd_from_file_1._asd_file = "some_name"
+ self.psd_from_file_2._asd_file = "some_other_name"
self.assertNotEqual(self.psd_from_file_1, self.psd_from_file_2)
def test_eq_false_different_frequency_array(self):
@@ -1417,5 +1705,5 @@ class TestPowerSpectralDensityEquals(unittest.TestCase):
self.assertNotEqual(self.psd_from_array_1, self.psd_from_array_2)
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/example_test.py b/test/example_test.py
index b478768ca90fa2e6f241d9dc60bdbaca84e5b292..0196f40b09449b48f877116fe5421b9b72f0bcb6 100644
--- a/test/example_test.py
+++ b/test/example_test.py
@@ -1,6 +1,7 @@
from __future__ import absolute_import
import matplotlib
-matplotlib.use('Agg')
+
+matplotlib.use("Agg")
import unittest
import os
@@ -12,14 +13,14 @@ from past.builtins import execfile
import bilby.core.utils
# Imported to ensure the examples run
-import numpy as np
-import inspect
+import numpy as np # noqa: F401
+import inspect # noqa: F401
bilby.core.utils.command_line_args.bilby_test_mode = True
class Test(unittest.TestCase):
- outdir = 'outdir'
+ outdir = "outdir"
dir_path = os.path.dirname(os.path.realpath(__file__))
dir_path = os.path.abspath(os.path.join(dir_path, os.path.pardir))
@@ -29,8 +30,7 @@ class Test(unittest.TestCase):
try:
shutil.rmtree(self.outdir)
except OSError:
- logging.warning(
- "{} not removed prior to tests".format(self.outdir))
+ logging.warning("{} not removed prior to tests".format(self.outdir))
@classmethod
def tearDownClass(self):
@@ -38,20 +38,18 @@ class Test(unittest.TestCase):
try:
shutil.rmtree(self.outdir)
except OSError:
- logging.warning(
- "{} not removed prior to tests".format(self.outdir))
+ logging.warning("{} not removed prior to tests".format(self.outdir))
def test_examples(self):
""" Loop over examples to check they run """
- examples = ['examples/core_examples/linear_regression.py',
- 'examples/core_examples/linear_regression_unknown_noise.py',
- ]
+ examples = [
+ "examples/core_examples/linear_regression.py",
+ "examples/core_examples/linear_regression_unknown_noise.py",
+ ]
for filename in examples:
print("Testing {}".format(filename))
execfile(filename)
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
-
-
diff --git a/test/grid_test.py b/test/grid_test.py
index e67ecf00783b3ef1b5f1c0b3753044b8382973b3..0450fd6c5144e7db8228a2fc077d29c2cdd48525 100644
--- a/test/grid_test.py
+++ b/test/grid_test.py
@@ -2,10 +2,8 @@ from __future__ import absolute_import, division
import unittest
import numpy as np
-import pandas as pd
import shutil
import os
-import json
from scipy.stats import multivariate_normal
import bilby
@@ -30,32 +28,41 @@ class MultiGaussian(bilby.Likelihood):
class TestGrid(unittest.TestCase):
-
def setUp(self):
np.random.seed(7)
-
+
# set 2D multivariate Gaussian (zero mean, unit variance)
- self.mus = [0., 0.]
- self.cov = [[1., 0.], [0., 1.]]
+ self.mus = [0.0, 0.0]
+ self.cov = [[1.0, 0.0], [0.0, 1.0]]
dim = len(self.mus)
self.likelihood = MultiGaussian(self.mus, self.cov)
-
+
# set priors out to +/- 5 sigma
self.priors = bilby.core.prior.PriorDict()
self.priors.update(
- {"x{0}".format(i): bilby.core.prior.Uniform(-5, 5, "x{0}".format(i)) for i in range(dim)}
+ {
+ "x{0}".format(i): bilby.core.prior.Uniform(-5, 5, "x{0}".format(i))
+ for i in range(dim)
+ }
)
# expected evidence integral should be (1/V) where V is the prior volume
- log_prior_vol = np.sum(np.log([prior.maximum - prior.minimum for key, prior in self.priors.items()]))
+ log_prior_vol = np.sum(
+ np.log(
+ [prior.maximum - prior.minimum for key, prior in self.priors.items()]
+ )
+ )
self.expected_ln_evidence = -log_prior_vol
self.grid_size = 100
grid = bilby.core.grid.Grid(
- label='label', outdir='outdir', priors=self.priors,
- grid_size=self.grid_size, likelihood=self.likelihood,
- save=True
+ label="label",
+ outdir="outdir",
+ priors=self.priors,
+ grid_size=self.grid_size,
+ likelihood=self.likelihood,
+ save=True,
)
self.grid = grid
@@ -71,29 +78,33 @@ class TestGrid(unittest.TestCase):
pass
def test_grid_file_name_default(self):
- outdir = 'outdir'
- label = 'label'
- self.assertEqual(bilby.core.grid.grid_file_name(outdir, label),
- '{}/{}_grid.json'.format(outdir, label))
- self.assertEqual(bilby.core.grid.grid_file_name(outdir, label, True),
- '{}/{}_grid.json.gz'.format(outdir, label))
+ outdir = "outdir"
+ label = "label"
+ self.assertEqual(
+ bilby.core.grid.grid_file_name(outdir, label),
+ "{}/{}_grid.json".format(outdir, label),
+ )
+ self.assertEqual(
+ bilby.core.grid.grid_file_name(outdir, label, True),
+ "{}/{}_grid.json.gz".format(outdir, label),
+ )
def test_fail_save_and_load(self):
with self.assertRaises(ValueError):
bilby.core.grid.Grid.read()
with self.assertRaises(IOError):
- bilby.core.grid.Grid.read(filename='not/a/file.json')
+ bilby.core.grid.Grid.read(filename="not/a/file.json")
def test_fail_marginalize(self):
with self.assertRaises(TypeError):
self.grid.marginalize_posterior(parameters=2.4)
-
+
with self.assertRaises(TypeError):
self.grid.marginalize_posterior(not_parameters=4.7)
-
+
with self.assertRaises(ValueError):
- self.grid.marginalize_posterior(parameters='jkgsd')
+ self.grid.marginalize_posterior(parameters="jkgsd")
def test_parameter_names(self):
assert list(self.priors.keys()) == self.grid.parameter_names
@@ -102,94 +113,150 @@ class TestGrid(unittest.TestCase):
def test_no_marginalization(self):
# test arrays are the same if no parameters are given to marginalize
# over
- assert np.array_equal(self.grid.ln_likelihood,
- self.grid.marginalize_ln_likelihood(not_parameters=self.grid.parameter_names))
-
+ assert np.array_equal(
+ self.grid.ln_likelihood,
+ self.grid.marginalize_ln_likelihood(
+ not_parameters=self.grid.parameter_names
+ ),
+ )
+
def test_marginalization_shapes(self):
assert len(self.grid.marginalize_ln_likelihood().shape) == 0
-
- marg1 = self.grid.marginalize_ln_likelihood(parameters=self.grid.parameter_names[0])
+
+ marg1 = self.grid.marginalize_ln_likelihood(
+ parameters=self.grid.parameter_names[0]
+ )
assert marg1.shape == (self.grid_size,)
- marg2 = self.grid.marginalize_ln_likelihood(parameters=self.grid.parameter_names[1])
+ marg2 = self.grid.marginalize_ln_likelihood(
+ parameters=self.grid.parameter_names[1]
+ )
assert marg2.shape == (self.grid_size,)
assert self.grid.ln_likelihood.shape == (self.grid_size, self.grid_size)
assert self.grid.ln_posterior.shape == (self.grid_size, self.grid_size)
def test_marginalization_opposite(self):
- assert np.array_equal(self.grid.marginalize_ln_likelihood(parameters=self.grid.parameter_names[0]),
- self.grid.marginalize_ln_likelihood(not_parameters=self.grid.parameter_names[1]))
- assert np.array_equal(self.grid.marginalize_ln_likelihood(parameters=self.grid.parameter_names[1]),
- self.grid.marginalize_ln_likelihood(not_parameters=self.grid.parameter_names[0]))
-
+ assert np.array_equal(
+ self.grid.marginalize_ln_likelihood(
+ parameters=self.grid.parameter_names[0]
+ ),
+ self.grid.marginalize_ln_likelihood(
+ not_parameters=self.grid.parameter_names[1]
+ ),
+ )
+ assert np.array_equal(
+ self.grid.marginalize_ln_likelihood(
+ parameters=self.grid.parameter_names[1]
+ ),
+ self.grid.marginalize_ln_likelihood(
+ not_parameters=self.grid.parameter_names[0]
+ ),
+ )
+
def test_max_marginalized_likelihood(self):
# marginalised likelihoods should have max values of 1 (as they are not
# properly normalised)
- assert self.grid.marginalize_likelihood(self.grid.parameter_names[0]).max() == 1.
- assert self.grid.marginalize_likelihood(self.grid.parameter_names[1]).max() == 1.
+ assert (
+ self.grid.marginalize_likelihood(self.grid.parameter_names[0]).max() == 1.0
+ )
+ assert (
+ self.grid.marginalize_likelihood(self.grid.parameter_names[1]).max() == 1.0
+ )
def test_ln_evidence(self):
assert np.isclose(self.grid.ln_evidence, self.expected_ln_evidence)
def test_fail_grid_size(self):
with self.assertRaises(TypeError):
- grid = bilby.core.grid.Grid(
- label='label', outdir='outdir', priors=self.priors,
- grid_size=2.3, likelihood=self.likelihood,
- save=True
+ bilby.core.grid.Grid(
+ label="label",
+ outdir="outdir",
+ priors=self.priors,
+ grid_size=2.3,
+ likelihood=self.likelihood,
+ save=True,
)
def test_mesh_grid(self):
assert self.grid.mesh_grid[0].shape == (self.grid_size, self.grid_size)
- assert self.grid.mesh_grid[0][0,0] == self.priors[self.grid.parameter_names[0]].minimum
- assert self.grid.mesh_grid[0][-1,-1] == self.priors[self.grid.parameter_names[1]].maximum
+ assert (
+ self.grid.mesh_grid[0][0, 0]
+ == self.priors[self.grid.parameter_names[0]].minimum
+ )
+ assert (
+ self.grid.mesh_grid[0][-1, -1]
+ == self.priors[self.grid.parameter_names[1]].maximum
+ )
def test_different_grids(self):
npoints = [10, 20]
grid = bilby.core.grid.Grid(
- label='label', outdir='outdir', priors=self.priors,
- grid_size=npoints, likelihood=self.likelihood
+ label="label",
+ outdir="outdir",
+ priors=self.priors,
+ grid_size=npoints,
+ likelihood=self.likelihood,
)
assert grid.mesh_grid[0].shape == tuple(npoints)
- assert grid.mesh_grid[0][0,0] == self.priors[self.grid.parameter_names[0]].minimum
- assert grid.mesh_grid[0][-1,-1] == self.priors[self.grid.parameter_names[1]].maximum
+ assert (
+ grid.mesh_grid[0][0, 0] == self.priors[self.grid.parameter_names[0]].minimum
+ )
+ assert (
+ grid.mesh_grid[0][-1, -1]
+ == self.priors[self.grid.parameter_names[1]].maximum
+ )
del grid
- npoints = {'x0': 15, 'x1': 18}
+ npoints = {"x0": 15, "x1": 18}
grid = bilby.core.grid.Grid(
- label='label', outdir='outdir', priors=self.priors,
- grid_size=npoints, likelihood=self.likelihood
+ label="label",
+ outdir="outdir",
+ priors=self.priors,
+ grid_size=npoints,
+ likelihood=self.likelihood,
)
- assert grid.mesh_grid[0].shape == (npoints['x0'], npoints['x1'])
- assert grid.mesh_grid[0][0,0] == self.priors[self.grid.parameter_names[0]].minimum
- assert grid.mesh_grid[0][-1,-1] == self.priors[self.grid.parameter_names[1]].maximum
+ assert grid.mesh_grid[0].shape == (npoints["x0"], npoints["x1"])
+ assert (
+ grid.mesh_grid[0][0, 0] == self.priors[self.grid.parameter_names[0]].minimum
+ )
+ assert (
+ grid.mesh_grid[0][-1, -1]
+ == self.priors[self.grid.parameter_names[1]].maximum
+ )
del grid
- x0s = np.linspace(self.priors['x0'].minimum, self.priors['x0'].maximum, 13)
- x1s = np.linspace(self.priors['x0'].minimum, self.priors['x0'].maximum, 14)
- npoints = {'x0': x0s,
- 'x1': x1s}
+ x0s = np.linspace(self.priors["x0"].minimum, self.priors["x0"].maximum, 13)
+ x1s = np.linspace(self.priors["x0"].minimum, self.priors["x0"].maximum, 14)
+ npoints = {"x0": x0s, "x1": x1s}
grid = bilby.core.grid.Grid(
- label='label', outdir='outdir', priors=self.priors,
- grid_size=npoints, likelihood=self.likelihood
+ label="label",
+ outdir="outdir",
+ priors=self.priors,
+ grid_size=npoints,
+ likelihood=self.likelihood,
)
assert grid.mesh_grid[0].shape == (len(x0s), len(x1s))
- assert grid.mesh_grid[0][0,0] == self.priors[self.grid.parameter_names[0]].minimum
- assert grid.mesh_grid[0][-1,-1] == self.priors[self.grid.parameter_names[1]].maximum
- assert np.array_equal(grid.sample_points['x0'], x0s)
- assert np.array_equal(grid.sample_points['x1'], x1s)
+ assert (
+ grid.mesh_grid[0][0, 0] == self.priors[self.grid.parameter_names[0]].minimum
+ )
+ assert (
+ grid.mesh_grid[0][-1, -1]
+ == self.priors[self.grid.parameter_names[1]].maximum
+ )
+ assert np.array_equal(grid.sample_points["x0"], x0s)
+ assert np.array_equal(grid.sample_points["x1"], x1s)
def test_save_and_load(self):
- filename = os.path.join('outdir', 'test_output.json')
+ filename = os.path.join("outdir", "test_output.json")
self.grid.save_to_file(filename=filename)
@@ -200,24 +267,27 @@ class TestGrid(unittest.TestCase):
assert newgrid.n_dims == self.grid.n_dims
assert np.array_equal(newgrid.mesh_grid[0], self.grid.mesh_grid[0])
for par in newgrid.parameter_names:
- assert np.array_equal(newgrid.sample_points[par], self.grid.sample_points[par])
+ assert np.array_equal(
+ newgrid.sample_points[par], self.grid.sample_points[par]
+ )
assert newgrid.ln_evidence == self.grid.ln_evidence
assert np.array_equal(newgrid.ln_likelihood, self.grid.ln_likelihood)
assert np.array_equal(newgrid.ln_posterior, self.grid.ln_posterior)
del newgrid
- self.grid.save_to_file(overwrite=True, outdir='outdir')
+ self.grid.save_to_file(overwrite=True, outdir="outdir")
# load file
- newgrid = bilby.core.grid.Grid.read(outdir='outdir',
- label='label')
+ newgrid = bilby.core.grid.Grid.read(outdir="outdir", label="label")
assert newgrid.parameter_names == self.grid.parameter_names
assert newgrid.n_dims == self.grid.n_dims
assert np.array_equal(newgrid.mesh_grid[0], self.grid.mesh_grid[0])
for par in newgrid.parameter_names:
- assert np.array_equal(newgrid.sample_points[par], self.grid.sample_points[par])
+ assert np.array_equal(
+ newgrid.sample_points[par], self.grid.sample_points[par]
+ )
assert newgrid.ln_evidence == self.grid.ln_evidence
assert np.array_equal(newgrid.ln_likelihood, self.grid.ln_likelihood)
assert np.array_equal(newgrid.ln_posterior, self.grid.ln_posterior)
@@ -225,7 +295,7 @@ class TestGrid(unittest.TestCase):
del newgrid
def test_save_and_load_gzip(self):
- filename = os.path.join('outdir', 'test_output.json.gz')
+ filename = os.path.join("outdir", "test_output.json.gz")
self.grid.save_to_file(filename=filename)
@@ -236,25 +306,27 @@ class TestGrid(unittest.TestCase):
assert newgrid.n_dims == self.grid.n_dims
assert np.array_equal(newgrid.mesh_grid[0], self.grid.mesh_grid[0])
for par in newgrid.parameter_names:
- assert np.array_equal(newgrid.sample_points[par], self.grid.sample_points[par])
+ assert np.array_equal(
+ newgrid.sample_points[par], self.grid.sample_points[par]
+ )
assert newgrid.ln_evidence == self.grid.ln_evidence
assert np.array_equal(newgrid.ln_likelihood, self.grid.ln_likelihood)
assert np.array_equal(newgrid.ln_posterior, self.grid.ln_posterior)
del newgrid
- self.grid.save_to_file(overwrite=True, outdir='outdir',
- gzip=True)
+ self.grid.save_to_file(overwrite=True, outdir="outdir", gzip=True)
# load file
- newgrid = bilby.core.grid.Grid.read(outdir='outdir', label='label',
- gzip=True)
+ newgrid = bilby.core.grid.Grid.read(outdir="outdir", label="label", gzip=True)
assert newgrid.parameter_names == self.grid.parameter_names
assert newgrid.n_dims == self.grid.n_dims
assert np.array_equal(newgrid.mesh_grid[0], self.grid.mesh_grid[0])
for par in newgrid.parameter_names:
- assert np.array_equal(newgrid.sample_points[par], self.grid.sample_points[par])
+ assert np.array_equal(
+ newgrid.sample_points[par], self.grid.sample_points[par]
+ )
assert newgrid.ln_evidence == self.grid.ln_evidence
assert np.array_equal(newgrid.ln_likelihood, self.grid.ln_likelihood)
assert np.array_equal(newgrid.ln_posterior, self.grid.ln_posterior)
diff --git a/test/gw_example_test.py b/test/gw_example_test.py
index 46e8d5f4e627810bf5fd8f2018d199e78d4bb83a..4c5c1c1aa198684e49c0bae52d63a9e4df77ef68 100644
--- a/test/gw_example_test.py
+++ b/test/gw_example_test.py
@@ -1,6 +1,7 @@
from __future__ import absolute_import
import matplotlib
-matplotlib.use('Agg')
+
+matplotlib.use("Agg")
import unittest
import os
@@ -12,14 +13,14 @@ from past.builtins import execfile
import bilby.core.utils
# Imported to ensure the examples run
-import numpy as np
-import inspect
+import numpy as np # noqa: F401
+import inspect # noqa: F401
bilby.core.utils.command_line_args.bilby_test_mode = True
class Test(unittest.TestCase):
- outdir = 'outdir'
+ outdir = "outdir"
dir_path = os.path.dirname(os.path.realpath(__file__))
dir_path = os.path.abspath(os.path.join(dir_path, os.path.pardir))
@@ -29,8 +30,7 @@ class Test(unittest.TestCase):
try:
shutil.rmtree(self.outdir)
except OSError:
- logging.warning(
- "{} not removed prior to tests".format(self.outdir))
+ logging.warning("{} not removed prior to tests".format(self.outdir))
@classmethod
def tearDownClass(self):
@@ -38,18 +38,18 @@ class Test(unittest.TestCase):
try:
shutil.rmtree(self.outdir)
except OSError:
- logging.warning(
- "{} not removed prior to tests".format(self.outdir))
+ logging.warning("{} not removed prior to tests".format(self.outdir))
def test_examples(self):
""" Loop over examples to check they run """
- examples = ['examples/gw_examples/injection_examples/fast_tutorial.py',
- 'examples/gw_examples/data_examples/GW150914.py',
- ]
+ examples = [
+ "examples/gw_examples/injection_examples/fast_tutorial.py",
+ "examples/gw_examples/data_examples/GW150914.py",
+ ]
for filename in examples:
print("Testing {}".format(filename))
execfile(filename)
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/gw_likelihood_test.py b/test/gw_likelihood_test.py
index d5bf45bcf64e59ce1cc146921044c2f4490c585e..9c50c0f73569d3b3c807346a98a9d758997b54a7 100644
--- a/test/gw_likelihood_test.py
+++ b/test/gw_likelihood_test.py
@@ -8,25 +8,38 @@ from bilby.gw.likelihood import BilbyROQParamsRangeError
class TestBasicGWTransient(unittest.TestCase):
-
def setUp(self):
np.random.seed(500)
self.parameters = dict(
- mass_1=31., mass_2=29., a_1=0.4, a_2=0.3, tilt_1=0.0, tilt_2=0.0,
- phi_12=1.7, phi_jl=0.3, luminosity_distance=4000., theta_jn=0.4,
- psi=2.659, phase=1.3, geocent_time=1126259642.413, ra=1.375,
- dec=-1.2108)
- self.interferometers = bilby.gw.detector.InterferometerList(['H1'])
+ mass_1=31.0,
+ mass_2=29.0,
+ a_1=0.4,
+ a_2=0.3,
+ tilt_1=0.0,
+ tilt_2=0.0,
+ phi_12=1.7,
+ phi_jl=0.3,
+ luminosity_distance=4000.0,
+ theta_jn=0.4,
+ psi=2.659,
+ phase=1.3,
+ geocent_time=1126259642.413,
+ ra=1.375,
+ dec=-1.2108,
+ )
+ self.interferometers = bilby.gw.detector.InterferometerList(["H1"])
self.interferometers.set_strain_data_from_power_spectral_densities(
- sampling_frequency=2048, duration=4)
+ sampling_frequency=2048, duration=4
+ )
self.waveform_generator = bilby.gw.waveform_generator.WaveformGenerator(
- duration=4, sampling_frequency=2048,
+ duration=4,
+ sampling_frequency=2048,
frequency_domain_source_model=bilby.gw.source.lal_binary_black_hole,
- )
+ )
self.likelihood = bilby.gw.likelihood.BasicGravitationalWaveTransient(
interferometers=self.interferometers,
- waveform_generator=self.waveform_generator
+ waveform_generator=self.waveform_generator,
)
self.likelihood.parameters = self.parameters.copy()
@@ -39,62 +52,78 @@ class TestBasicGWTransient(unittest.TestCase):
def test_noise_log_likelihood(self):
"""Test noise log likelihood matches precomputed value"""
self.likelihood.noise_log_likelihood()
- self.assertAlmostEqual(-4037.0994372143414, self.likelihood.noise_log_likelihood(), 3)
+ self.assertAlmostEqual(
+ -4037.0994372143414, self.likelihood.noise_log_likelihood(), 3
+ )
def test_log_likelihood(self):
"""Test log likelihood matches precomputed value"""
self.likelihood.log_likelihood()
- self.assertAlmostEqual(self.likelihood.log_likelihood(),
- -4054.047229508672, 3)
+ self.assertAlmostEqual(self.likelihood.log_likelihood(), -4054.047229508672, 3)
def test_log_likelihood_ratio(self):
"""Test log likelihood ratio returns the correct value"""
self.assertAlmostEqual(
- self.likelihood.log_likelihood()
- - self.likelihood.noise_log_likelihood(),
- self.likelihood.log_likelihood_ratio(), 3)
+ self.likelihood.log_likelihood() - self.likelihood.noise_log_likelihood(),
+ self.likelihood.log_likelihood_ratio(),
+ 3,
+ )
def test_likelihood_zero_when_waveform_is_none(self):
"""Test log likelihood returns np.nan_to_num(-np.inf) when the
waveform is None"""
- self.likelihood.waveform_generator.frequency_domain_strain = \
- lambda x: None
- self.assertEqual(self.likelihood.log_likelihood_ratio(),
- np.nan_to_num(-np.inf))
+ self.likelihood.waveform_generator.frequency_domain_strain = lambda x: None
+ self.assertEqual(self.likelihood.log_likelihood_ratio(), np.nan_to_num(-np.inf))
def test_repr(self):
- expected = 'BasicGravitationalWaveTransient(interferometers={},\n\twaveform_generator={})'.format(
- self.interferometers, self.waveform_generator)
+ expected = "BasicGravitationalWaveTransient(interferometers={},\n\twaveform_generator={})".format(
+ self.interferometers, self.waveform_generator
+ )
self.assertEqual(expected, repr(self.likelihood))
class TestGWTransient(unittest.TestCase):
-
def setUp(self):
np.random.seed(500)
self.duration = 4
self.sampling_frequency = 2048
self.parameters = dict(
- mass_1=31., mass_2=29., a_1=0.4, a_2=0.3, tilt_1=0.0, tilt_2=0.0,
- phi_12=1.7, phi_jl=0.3, luminosity_distance=4000., theta_jn=0.4,
- psi=2.659, phase=1.3, geocent_time=1126259642.413, ra=1.375,
- dec=-1.2108)
- self.interferometers = bilby.gw.detector.InterferometerList(['H1'])
+ mass_1=31.0,
+ mass_2=29.0,
+ a_1=0.4,
+ a_2=0.3,
+ tilt_1=0.0,
+ tilt_2=0.0,
+ phi_12=1.7,
+ phi_jl=0.3,
+ luminosity_distance=4000.0,
+ theta_jn=0.4,
+ psi=2.659,
+ phase=1.3,
+ geocent_time=1126259642.413,
+ ra=1.375,
+ dec=-1.2108,
+ )
+ self.interferometers = bilby.gw.detector.InterferometerList(["H1"])
self.interferometers.set_strain_data_from_power_spectral_densities(
- sampling_frequency=self.sampling_frequency, duration=self.duration)
+ sampling_frequency=self.sampling_frequency, duration=self.duration
+ )
self.waveform_generator = bilby.gw.waveform_generator.WaveformGenerator(
- duration=self.duration, sampling_frequency=self.sampling_frequency,
+ duration=self.duration,
+ sampling_frequency=self.sampling_frequency,
frequency_domain_source_model=bilby.gw.source.lal_binary_black_hole,
)
self.prior = bilby.gw.prior.BBHPriorDict()
- self.prior['geocent_time'] = bilby.prior.Uniform(
- minimum=self.parameters['geocent_time'] - self.duration / 2,
- maximum=self.parameters['geocent_time'] + self.duration / 2)
+ self.prior["geocent_time"] = bilby.prior.Uniform(
+ minimum=self.parameters["geocent_time"] - self.duration / 2,
+ maximum=self.parameters["geocent_time"] + self.duration / 2,
+ )
self.likelihood = bilby.gw.likelihood.GravitationalWaveTransient(
interferometers=self.interferometers,
- waveform_generator=self.waveform_generator, priors=self.prior.copy()
+ waveform_generator=self.waveform_generator,
+ priors=self.prior.copy(),
)
self.likelihood.parameters = self.parameters.copy()
@@ -108,7 +137,9 @@ class TestGWTransient(unittest.TestCase):
def test_noise_log_likelihood(self):
"""Test noise log likelihood matches precomputed value"""
self.likelihood.noise_log_likelihood()
- self.assertAlmostEqual(-4037.0994372143414, self.likelihood.noise_log_likelihood(), 3)
+ self.assertAlmostEqual(
+ -4037.0994372143414, self.likelihood.noise_log_likelihood(), 3
+ )
def test_log_likelihood(self):
"""Test log likelihood matches precomputed value"""
@@ -119,36 +150,61 @@ class TestGWTransient(unittest.TestCase):
def test_log_likelihood_ratio(self):
"""Test log likelihood ratio returns the correct value"""
self.assertAlmostEqual(
- self.likelihood.log_likelihood()
- - self.likelihood.noise_log_likelihood(),
- self.likelihood.log_likelihood_ratio(), 3)
+ self.likelihood.log_likelihood() - self.likelihood.noise_log_likelihood(),
+ self.likelihood.log_likelihood_ratio(),
+ 3,
+ )
def test_likelihood_zero_when_waveform_is_none(self):
"""Test log likelihood returns np.nan_to_num(-np.inf) when the
waveform is None"""
- self.likelihood.waveform_generator.frequency_domain_strain =\
- lambda x: None
- self.assertEqual(self.likelihood.log_likelihood_ratio(),
- np.nan_to_num(-np.inf))
+ self.likelihood.waveform_generator.frequency_domain_strain = lambda x: None
+ self.assertEqual(self.likelihood.log_likelihood_ratio(), np.nan_to_num(-np.inf))
def test_repr(self):
- expected = 'GravitationalWaveTransient(interferometers={},\n\twaveform_generator={},\n\t' \
- 'time_marginalization={}, distance_marginalization={}, phase_marginalization={}, ' \
- 'priors={})'.format(self.interferometers, self.waveform_generator, False, False, False, self.prior)
+ expected = (
+ "GravitationalWaveTransient(interferometers={},\n\twaveform_generator={},\n\t"
+ "time_marginalization={}, distance_marginalization={}, phase_marginalization={}, "
+ "priors={})".format(
+ self.interferometers,
+ self.waveform_generator,
+ False,
+ False,
+ False,
+ self.prior,
+ )
+ )
self.assertEqual(expected, repr(self.likelihood))
def test_interferometers_setting_list(self):
- ifos = [bilby.gw.detector.get_empty_interferometer(name=name) for name in ['H1', 'L1']]
+ ifos = [
+ bilby.gw.detector.get_empty_interferometer(name=name)
+ for name in ["H1", "L1"]
+ ]
self.likelihood.interferometers = ifos
- self.assertListEqual(bilby.gw.detector.InterferometerList(ifos), self.likelihood.interferometers)
- self.assertTrue(type(self.likelihood.interferometers) == bilby.gw.detector.InterferometerList)
+ self.assertListEqual(
+ bilby.gw.detector.InterferometerList(ifos), self.likelihood.interferometers
+ )
+ self.assertTrue(
+ type(self.likelihood.interferometers)
+ == bilby.gw.detector.InterferometerList
+ )
def test_interferometers_setting_interferometer_list(self):
- ifos = bilby.gw.detector.InterferometerList([bilby.gw.detector.get_empty_interferometer(name=name)
- for name in ['H1', 'L1']])
+ ifos = bilby.gw.detector.InterferometerList(
+ [
+ bilby.gw.detector.get_empty_interferometer(name=name)
+ for name in ["H1", "L1"]
+ ]
+ )
self.likelihood.interferometers = ifos
- self.assertListEqual(bilby.gw.detector.InterferometerList(ifos), self.likelihood.interferometers)
- self.assertTrue(type(self.likelihood.interferometers) == bilby.gw.detector.InterferometerList)
+ self.assertListEqual(
+ bilby.gw.detector.InterferometerList(ifos), self.likelihood.interferometers
+ )
+ self.assertTrue(
+ type(self.likelihood.interferometers)
+ == bilby.gw.detector.InterferometerList
+ )
def test_meta_data(self):
expected = dict(
@@ -163,37 +219,54 @@ class TestGWTransient(unittest.TestCase):
sampling_frequency=self.waveform_generator.sampling_frequency,
duration=self.waveform_generator.duration,
start_time=self.waveform_generator.start_time,
- lal_version=self.likelihood.lal_version)
+ lal_version=self.likelihood.lal_version,
+ )
self.assertDictEqual(expected, self.likelihood.meta_data)
class TestTimeMarginalization(unittest.TestCase):
-
def setUp(self):
np.random.seed(500)
self.duration = 4
self.sampling_frequency = 2048
self.parameters = dict(
- mass_1=31., mass_2=29., a_1=0.4, a_2=0.3, tilt_1=0.0, tilt_2=0.0,
- phi_12=1.7, phi_jl=0.3, luminosity_distance=4000., theta_jn=0.4,
- psi=2.659, phase=1.3, geocent_time=1126259640, ra=1.375,
- dec=-1.2108)
+ mass_1=31.0,
+ mass_2=29.0,
+ a_1=0.4,
+ a_2=0.3,
+ tilt_1=0.0,
+ tilt_2=0.0,
+ phi_12=1.7,
+ phi_jl=0.3,
+ luminosity_distance=4000.0,
+ theta_jn=0.4,
+ psi=2.659,
+ phase=1.3,
+ geocent_time=1126259640,
+ ra=1.375,
+ dec=-1.2108,
+ )
- self.interferometers = bilby.gw.detector.InterferometerList(['H1'])
+ self.interferometers = bilby.gw.detector.InterferometerList(["H1"])
self.interferometers.set_strain_data_from_power_spectral_densities(
- sampling_frequency=self.sampling_frequency, duration=self.duration,
- start_time=1126259640)
+ sampling_frequency=self.sampling_frequency,
+ duration=self.duration,
+ start_time=1126259640,
+ )
self.waveform_generator = bilby.gw.waveform_generator.WaveformGenerator(
- duration=self.duration, sampling_frequency=self.sampling_frequency,
+ duration=self.duration,
+ sampling_frequency=self.sampling_frequency,
frequency_domain_source_model=bilby.gw.source.lal_binary_black_hole,
- start_time=1126259640)
+ start_time=1126259640,
+ )
self.priors = bilby.gw.prior.BBHPriorDict()
self.likelihood = bilby.gw.likelihood.GravitationalWaveTransient(
interferometers=self.interferometers,
- waveform_generator=self.waveform_generator, priors=self.priors.copy()
+ waveform_generator=self.waveform_generator,
+ priors=self.priors.copy(),
)
self.likelihood.parameters = self.parameters.copy()
@@ -214,28 +287,32 @@ class TestTimeMarginalization(unittest.TestCase):
"""
likes = []
lls = []
- self.priors['geocent_time'] = bilby.prior.Uniform(
+ self.priors["geocent_time"] = bilby.prior.Uniform(
minimum=self.waveform_generator.start_time,
- maximum=self.waveform_generator.start_time + self.duration)
+ maximum=self.waveform_generator.start_time + self.duration,
+ )
self.time = bilby.gw.likelihood.GravitationalWaveTransient(
interferometers=self.interferometers,
waveform_generator=self.waveform_generator,
- time_marginalization=True, priors=self.priors
+ time_marginalization=True,
+ priors=self.priors,
+ )
+ times = (
+ self.waveform_generator.start_time
+ + np.linspace(0, self.duration, 4097)[:-1]
)
- times = self.waveform_generator.start_time + np.linspace(
- 0, self.duration, 4097)[:-1]
for time in times:
- self.likelihood.parameters['geocent_time'] = time
+ self.likelihood.parameters["geocent_time"] = time
lls.append(self.likelihood.log_likelihood_ratio())
likes.append(np.exp(lls[-1]))
- marg_like = np.log(np.trapz(
- likes * self.time.priors['geocent_time'].prob(times), times))
+ marg_like = np.log(
+ np.trapz(likes * self.time.priors["geocent_time"].prob(times), times)
+ )
self.time.parameters = self.parameters.copy()
- self.time.parameters['time_jitter'] = 0.0
- self.time.parameters['geocent_time'] = self.waveform_generator.start_time
- self.assertAlmostEqual(marg_like, self.time.log_likelihood_ratio(),
- delta=0.5)
+ self.time.parameters["time_jitter"] = 0.0
+ self.time.parameters["geocent_time"] = self.waveform_generator.start_time
+ self.assertAlmostEqual(marg_like, self.time.log_likelihood_ratio(), delta=0.5)
def test_time_marginalisation_partial_segment(self):
"""
@@ -244,56 +321,75 @@ class TestTimeMarginalization(unittest.TestCase):
"""
likes = []
lls = []
- self.priors['geocent_time'] = bilby.prior.Uniform(
- minimum=self.parameters['geocent_time'] + 1 - 0.1,
- maximum=self.parameters['geocent_time'] + 1 + 0.1)
+ self.priors["geocent_time"] = bilby.prior.Uniform(
+ minimum=self.parameters["geocent_time"] + 1 - 0.1,
+ maximum=self.parameters["geocent_time"] + 1 + 0.1,
+ )
self.time = bilby.gw.likelihood.GravitationalWaveTransient(
interferometers=self.interferometers,
waveform_generator=self.waveform_generator,
- time_marginalization=True, priors=self.priors
+ time_marginalization=True,
+ priors=self.priors,
+ )
+ times = (
+ self.waveform_generator.start_time
+ + np.linspace(0, self.duration, 4097)[:-1]
)
- times = self.waveform_generator.start_time + np.linspace(
- 0, self.duration, 4097)[:-1]
for time in times:
- self.likelihood.parameters['geocent_time'] = time
+ self.likelihood.parameters["geocent_time"] = time
lls.append(self.likelihood.log_likelihood_ratio())
likes.append(np.exp(lls[-1]))
- marg_like = np.log(np.trapz(
- likes * self.time.priors['geocent_time'].prob(times), times))
+ marg_like = np.log(
+ np.trapz(likes * self.time.priors["geocent_time"].prob(times), times)
+ )
self.time.parameters = self.parameters.copy()
- self.time.parameters['time_jitter'] = 0.0
- self.time.parameters['geocent_time'] = self.waveform_generator.start_time
- self.assertAlmostEqual(marg_like, self.time.log_likelihood_ratio(),
- delta=0.5)
+ self.time.parameters["time_jitter"] = 0.0
+ self.time.parameters["geocent_time"] = self.waveform_generator.start_time
+ self.assertAlmostEqual(marg_like, self.time.log_likelihood_ratio(), delta=0.5)
class TestMarginalizedLikelihood(unittest.TestCase):
-
def setUp(self):
np.random.seed(500)
self.duration = 4
self.sampling_frequency = 2048
self.parameters = dict(
- mass_1=31., mass_2=29., a_1=0.4, a_2=0.3, tilt_1=0.0, tilt_2=0.0,
- phi_12=1.7, phi_jl=0.3, luminosity_distance=4000., theta_jn=0.4,
- psi=2.659, phase=1.3, geocent_time=1126259642.413, ra=1.375,
- dec=-1.2108)
+ mass_1=31.0,
+ mass_2=29.0,
+ a_1=0.4,
+ a_2=0.3,
+ tilt_1=0.0,
+ tilt_2=0.0,
+ phi_12=1.7,
+ phi_jl=0.3,
+ luminosity_distance=4000.0,
+ theta_jn=0.4,
+ psi=2.659,
+ phase=1.3,
+ geocent_time=1126259642.413,
+ ra=1.375,
+ dec=-1.2108,
+ )
- self.interferometers = bilby.gw.detector.InterferometerList(['H1'])
+ self.interferometers = bilby.gw.detector.InterferometerList(["H1"])
self.interferometers.set_strain_data_from_power_spectral_densities(
- sampling_frequency=self.sampling_frequency, duration=self.duration,
- start_time=self.parameters['geocent_time'] - self.duration / 2)
+ sampling_frequency=self.sampling_frequency,
+ duration=self.duration,
+ start_time=self.parameters["geocent_time"] - self.duration / 2,
+ )
self.waveform_generator = bilby.gw.waveform_generator.WaveformGenerator(
- duration=self.duration, sampling_frequency=self.sampling_frequency,
+ duration=self.duration,
+ sampling_frequency=self.sampling_frequency,
frequency_domain_source_model=bilby.gw.source.lal_binary_black_hole,
)
self.prior = bilby.gw.prior.BBHPriorDict()
- self.prior['geocent_time'] = bilby.prior.Uniform(
- minimum=self.parameters['geocent_time'] - self.duration / 2,
- maximum=self.parameters['geocent_time'] + self.duration / 2)
+ self.prior["geocent_time"] = bilby.prior.Uniform(
+ minimum=self.parameters["geocent_time"] - self.duration / 2,
+ maximum=self.parameters["geocent_time"] + self.duration / 2,
+ )
def test_cannot_instantiate_marginalised_likelihood_without_prior(self):
self.assertRaises(
@@ -301,47 +397,71 @@ class TestMarginalizedLikelihood(unittest.TestCase):
lambda: bilby.gw.likelihood.GravitationalWaveTransient(
interferometers=self.interferometers,
waveform_generator=self.waveform_generator,
- phase_marginalization=True))
+ phase_marginalization=True,
+ ),
+ )
def test_generating_default_time_prior(self):
- temp = self.prior.pop('geocent_time')
+ temp = self.prior.pop("geocent_time")
new_prior = self.prior.copy()
like = bilby.gw.likelihood.GravitationalWaveTransient(
interferometers=self.interferometers,
- waveform_generator=self.waveform_generator, priors=new_prior,
- time_marginalization=True
+ waveform_generator=self.waveform_generator,
+ priors=new_prior,
+ time_marginalization=True,
+ )
+ same = all(
+ [
+ temp.minimum == like.priors["geocent_time"].minimum,
+ temp.maximum == like.priors["geocent_time"].maximum,
+ new_prior["geocent_time"] == temp.minimum,
+ ]
)
- same = all([temp.minimum == like.priors['geocent_time'].minimum,
- temp.maximum == like.priors['geocent_time'].maximum,
- new_prior['geocent_time'] == temp.minimum])
self.assertTrue(same)
- self.prior['geocent_time'] = temp
+ self.prior["geocent_time"] = temp
def test_generating_default_phase_prior(self):
- temp = self.prior.pop('phase')
+ temp = self.prior.pop("phase")
new_prior = self.prior.copy()
like = bilby.gw.likelihood.GravitationalWaveTransient(
interferometers=self.interferometers,
- waveform_generator=self.waveform_generator, priors=new_prior,
- phase_marginalization=True
+ waveform_generator=self.waveform_generator,
+ priors=new_prior,
+ phase_marginalization=True,
+ )
+ same = all(
+ [
+ temp.minimum == like.priors["phase"].minimum,
+ temp.maximum == like.priors["phase"].maximum,
+ new_prior["phase"] == float(0),
+ ]
)
- same = all([temp.minimum == like.priors['phase'].minimum,
- temp.maximum == like.priors['phase'].maximum,
- new_prior['phase'] == float(0)])
self.assertTrue(same)
- self.prior['phase'] = temp
+ self.prior["phase"] = temp
def test_run_sampler_flags_if_marginalized_phase_is_sampled(self):
like = bilby.gw.likelihood.GravitationalWaveTransient(
interferometers=self.interferometers,
- waveform_generator=self.waveform_generator, priors=self.prior,
- phase_marginalization=True
+ waveform_generator=self.waveform_generator,
+ priors=self.prior,
+ phase_marginalization=True,
)
new_prior = self.prior.copy()
- new_prior['phase'] = bilby.prior.Uniform(minimum=0, maximum=2*np.pi)
+ new_prior["phase"] = bilby.prior.Uniform(minimum=0, maximum=2 * np.pi)
for key, param in dict(
- mass_1=31., mass_2=29., a_1=0.4, a_2=0.3, tilt_1=0.0, tilt_2=0.0,
- phi_12=1.7, phi_jl=0.3, theta_jn=0.4, psi=2.659, ra=1.375, dec=-1.2108).items():
+ mass_1=31.0,
+ mass_2=29.0,
+ a_1=0.4,
+ a_2=0.3,
+ tilt_1=0.0,
+ tilt_2=0.0,
+ phi_12=1.7,
+ phi_jl=0.3,
+ theta_jn=0.4,
+ psi=2.659,
+ ra=1.375,
+ dec=-1.2108,
+ ).items():
new_prior[key] = param
with self.assertRaises(bilby.core.sampler.SamplingMarginalisedParameterError):
bilby.run_sampler(like, new_prior)
@@ -349,54 +469,82 @@ class TestMarginalizedLikelihood(unittest.TestCase):
def test_run_sampler_flags_if_marginalized_time_is_sampled(self):
like = bilby.gw.likelihood.GravitationalWaveTransient(
interferometers=self.interferometers,
- waveform_generator=self.waveform_generator, priors=self.prior,
- time_marginalization=True
+ waveform_generator=self.waveform_generator,
+ priors=self.prior,
+ time_marginalization=True,
)
new_prior = self.prior.copy()
- new_prior['geocent_time'] = bilby.prior.Uniform(minimum=0, maximum=1)
+ new_prior["geocent_time"] = bilby.prior.Uniform(minimum=0, maximum=1)
for key, param in dict(
- mass_1=31., mass_2=29., a_1=0.4, a_2=0.3, tilt_1=0.0, tilt_2=0.0,
- phi_12=1.7, phi_jl=0.3, theta_jn=0.4, psi=2.659, ra=1.375, dec=-1.2108).items():
+ mass_1=31.0,
+ mass_2=29.0,
+ a_1=0.4,
+ a_2=0.3,
+ tilt_1=0.0,
+ tilt_2=0.0,
+ phi_12=1.7,
+ phi_jl=0.3,
+ theta_jn=0.4,
+ psi=2.659,
+ ra=1.375,
+ dec=-1.2108,
+ ).items():
new_prior[key] = param
with self.assertRaises(bilby.core.sampler.SamplingMarginalisedParameterError):
bilby.run_sampler(like, new_prior)
class TestPhaseMarginalization(unittest.TestCase):
-
def setUp(self):
np.random.seed(500)
self.duration = 4
self.sampling_frequency = 2048
self.parameters = dict(
- mass_1=31., mass_2=29., a_1=0.4, a_2=0.3, tilt_1=0.0, tilt_2=0.0,
- phi_12=1.7, phi_jl=0.3, luminosity_distance=4000., theta_jn=0.4,
- psi=2.659, phase=1.3, geocent_time=1126259642.413, ra=1.375,
- dec=-1.2108)
+ mass_1=31.0,
+ mass_2=29.0,
+ a_1=0.4,
+ a_2=0.3,
+ tilt_1=0.0,
+ tilt_2=0.0,
+ phi_12=1.7,
+ phi_jl=0.3,
+ luminosity_distance=4000.0,
+ theta_jn=0.4,
+ psi=2.659,
+ phase=1.3,
+ geocent_time=1126259642.413,
+ ra=1.375,
+ dec=-1.2108,
+ )
- self.interferometers = bilby.gw.detector.InterferometerList(['H1'])
+ self.interferometers = bilby.gw.detector.InterferometerList(["H1"])
self.interferometers.set_strain_data_from_power_spectral_densities(
- sampling_frequency=self.sampling_frequency, duration=self.duration)
+ sampling_frequency=self.sampling_frequency, duration=self.duration
+ )
self.waveform_generator = bilby.gw.waveform_generator.WaveformGenerator(
- duration=self.duration, sampling_frequency=self.sampling_frequency,
+ duration=self.duration,
+ sampling_frequency=self.sampling_frequency,
frequency_domain_source_model=bilby.gw.source.lal_binary_black_hole,
)
self.prior = bilby.gw.prior.BBHPriorDict()
- self.prior['geocent_time'] = bilby.prior.Uniform(
- minimum=self.parameters['geocent_time'] - self.duration / 2,
- maximum=self.parameters['geocent_time'] + self.duration / 2)
+ self.prior["geocent_time"] = bilby.prior.Uniform(
+ minimum=self.parameters["geocent_time"] - self.duration / 2,
+ maximum=self.parameters["geocent_time"] + self.duration / 2,
+ )
self.likelihood = bilby.gw.likelihood.GravitationalWaveTransient(
interferometers=self.interferometers,
- waveform_generator=self.waveform_generator, priors=self.prior.copy()
+ waveform_generator=self.waveform_generator,
+ priors=self.prior.copy(),
)
self.phase = bilby.gw.likelihood.GravitationalWaveTransient(
interferometers=self.interferometers,
waveform_generator=self.waveform_generator,
- phase_marginalization=True, priors=self.prior.copy()
+ phase_marginalization=True,
+ priors=self.prior.copy(),
)
for like in [self.likelihood, self.phase]:
like.parameters = self.parameters.copy()
@@ -416,64 +564,83 @@ class TestPhaseMarginalization(unittest.TestCase):
like = []
phases = np.linspace(0, 2 * np.pi, 1000)
for phase in phases:
- self.likelihood.parameters['phase'] = phase
+ self.likelihood.parameters["phase"] = phase
like.append(np.exp(self.likelihood.log_likelihood_ratio()))
marg_like = np.log(np.trapz(like, phases) / (2 * np.pi))
self.phase.parameters = self.parameters.copy()
- self.assertAlmostEqual(marg_like, self.phase.log_likelihood_ratio(),
- delta=0.5)
+ self.assertAlmostEqual(marg_like, self.phase.log_likelihood_ratio(), delta=0.5)
class TestTimePhaseMarginalization(unittest.TestCase):
-
def setUp(self):
np.random.seed(500)
self.duration = 4
self.sampling_frequency = 2048
self.parameters = dict(
- mass_1=31., mass_2=29., a_1=0.4, a_2=0.3, tilt_1=0.0, tilt_2=0.0,
- phi_12=1.7, phi_jl=0.3, luminosity_distance=4000., theta_jn=0.4,
- psi=2.659, phase=1.3, geocent_time=1126259642.413, ra=1.375,
- dec=-1.2108)
+ mass_1=31.0,
+ mass_2=29.0,
+ a_1=0.4,
+ a_2=0.3,
+ tilt_1=0.0,
+ tilt_2=0.0,
+ phi_12=1.7,
+ phi_jl=0.3,
+ luminosity_distance=4000.0,
+ theta_jn=0.4,
+ psi=2.659,
+ phase=1.3,
+ geocent_time=1126259642.413,
+ ra=1.375,
+ dec=-1.2108,
+ )
- self.interferometers = bilby.gw.detector.InterferometerList(['H1'])
+ self.interferometers = bilby.gw.detector.InterferometerList(["H1"])
self.interferometers.set_strain_data_from_power_spectral_densities(
- sampling_frequency=self.sampling_frequency, duration=self.duration,
- start_time=1126259640)
+ sampling_frequency=self.sampling_frequency,
+ duration=self.duration,
+ start_time=1126259640,
+ )
self.waveform_generator = bilby.gw.waveform_generator.WaveformGenerator(
- duration=self.duration, sampling_frequency=self.sampling_frequency,
+ duration=self.duration,
+ sampling_frequency=self.sampling_frequency,
frequency_domain_source_model=bilby.gw.source.lal_binary_black_hole,
- start_time=1126259640)
+ start_time=1126259640,
+ )
self.priors = bilby.gw.prior.BBHPriorDict()
- self.priors['geocent_time'] = bilby.prior.Uniform(
- minimum=self.parameters['geocent_time'] - self.duration / 2,
- maximum=self.parameters['geocent_time'] + self.duration / 2)
+ self.priors["geocent_time"] = bilby.prior.Uniform(
+ minimum=self.parameters["geocent_time"] - self.duration / 2,
+ maximum=self.parameters["geocent_time"] + self.duration / 2,
+ )
self.likelihood = bilby.gw.likelihood.GravitationalWaveTransient(
interferometers=self.interferometers,
- waveform_generator=self.waveform_generator, priors=self.priors.copy()
+ waveform_generator=self.waveform_generator,
+ priors=self.priors.copy(),
)
self.time = bilby.gw.likelihood.GravitationalWaveTransient(
interferometers=self.interferometers,
waveform_generator=self.waveform_generator,
- time_marginalization=True, priors=self.priors.copy()
+ time_marginalization=True,
+ priors=self.priors.copy(),
)
self.phase = bilby.gw.likelihood.GravitationalWaveTransient(
interferometers=self.interferometers,
waveform_generator=self.waveform_generator,
- phase_marginalization=True, priors=self.priors.copy()
+ phase_marginalization=True,
+ priors=self.priors.copy(),
)
self.time_phase = bilby.gw.likelihood.GravitationalWaveTransient(
interferometers=self.interferometers,
waveform_generator=self.waveform_generator,
- time_marginalization=True, phase_marginalization=True,
- priors=self.priors
+ time_marginalization=True,
+ phase_marginalization=True,
+ priors=self.priors,
)
for like in [self.likelihood, self.time, self.phase, self.time_phase]:
like.parameters = self.parameters.copy()
@@ -497,19 +664,20 @@ class TestTimePhaseMarginalization(unittest.TestCase):
"""
like = []
times = np.linspace(
- self.time_phase.priors['geocent_time'].minimum,
- self.time_phase.priors['geocent_time'].maximum, 4097)[:-1]
+ self.time_phase.priors["geocent_time"].minimum,
+ self.time_phase.priors["geocent_time"].maximum,
+ 4097,
+ )[:-1]
for time in times:
- self.phase.parameters['geocent_time'] = time
+ self.phase.parameters["geocent_time"] = time
like.append(np.exp(self.phase.log_likelihood_ratio()))
- marg_like = np.log(np.trapz(like, times)
- / self.waveform_generator.duration)
+ marg_like = np.log(np.trapz(like, times) / self.waveform_generator.duration)
self.time_phase.parameters = self.parameters.copy()
- self.time_phase.parameters['time_jitter'] = 0.0
- self.assertAlmostEqual(marg_like,
- self.time_phase.log_likelihood_ratio(),
- delta=0.5)
+ self.time_phase.parameters["time_jitter"] = 0.0
+ self.assertAlmostEqual(
+ marg_like, self.time_phase.log_likelihood_ratio(), delta=0.5
+ )
def test_phase_marginalisation(self):
"""
@@ -519,20 +687,19 @@ class TestTimePhaseMarginalization(unittest.TestCase):
like = []
phases = np.linspace(0, 2 * np.pi, 1000)
for phase in phases:
- self.time.parameters['phase'] = phase
- self.time.parameters['time_jitter'] = 0.0
+ self.time.parameters["phase"] = phase
+ self.time.parameters["time_jitter"] = 0.0
like.append(np.exp(self.time.log_likelihood_ratio()))
marg_like = np.log(np.trapz(like, phases) / (2 * np.pi))
self.time_phase.parameters = self.parameters.copy()
- self.time_phase.parameters['time_jitter'] = 0.0
- self.assertAlmostEqual(marg_like,
- self.time_phase.log_likelihood_ratio(),
- delta=0.5)
+ self.time_phase.parameters["time_jitter"] = 0.0
+ self.assertAlmostEqual(
+ marg_like, self.time_phase.log_likelihood_ratio(), delta=0.5
+ )
class TestROQLikelihood(unittest.TestCase):
-
def setUp(self):
self.duration = 4
self.sampling_frequency = 2048
@@ -540,8 +707,9 @@ class TestROQLikelihood(unittest.TestCase):
# Possible locations for the ROQ: in the docker image, local, or on CIT
trial_roq_paths = [
"/roq_basis",
- os.path.join(os.path.expanduser("~"), 'ROQ_data/IMRPhenomPv2/4s'),
- "/home/cbc/ROQ_data/IMRPhenomPv2/4s"]
+ os.path.join(os.path.expanduser("~"), "ROQ_data/IMRPhenomPv2/4s"),
+ "/home/cbc/ROQ_data/IMRPhenomPv2/4s",
+ ]
roq_dir = None
for path in trial_roq_paths:
if os.path.isdir(path):
@@ -562,13 +730,27 @@ class TestROQLikelihood(unittest.TestCase):
self.params_file = "{}/params.dat".format(roq_dir)
self.test_parameters = dict(
- mass_1=36.0, mass_2=36.0, a_1=0.0, a_2=0.0, tilt_1=0.0, tilt_2=0.0,
- phi_12=1.7, phi_jl=0.3, luminosity_distance=1000., theta_jn=0.4,
- psi=0.659, phase=1.3, geocent_time=1.2, ra=1.3, dec=-1.2)
+ mass_1=36.0,
+ mass_2=36.0,
+ a_1=0.0,
+ a_2=0.0,
+ tilt_1=0.0,
+ tilt_2=0.0,
+ phi_12=1.7,
+ phi_jl=0.3,
+ luminosity_distance=1000.0,
+ theta_jn=0.4,
+ psi=0.659,
+ phase=1.3,
+ geocent_time=1.2,
+ ra=1.3,
+ dec=-1.2,
+ )
- ifos = bilby.gw.detector.InterferometerList(['H1'])
+ ifos = bilby.gw.detector.InterferometerList(["H1"])
ifos.set_strain_data_from_power_spectral_densities(
- sampling_frequency=self.sampling_frequency, duration=self.duration)
+ sampling_frequency=self.sampling_frequency, duration=self.duration
+ )
self.priors = bilby.gw.prior.BBHPriorDict()
self.priors.pop("mass_1")
@@ -576,123 +758,166 @@ class TestROQLikelihood(unittest.TestCase):
# Testing is done with the 4s IMRPhenomPV2 ROQ basis
self.priors["chirp_mass"] = bilby.core.prior.Uniform(12.299703, 45)
self.priors["mass_ratio"] = bilby.core.prior.Uniform(0.125, 1)
- self.priors['geocent_time'] = bilby.core.prior.Uniform(1.19, 1.21)
+ self.priors["geocent_time"] = bilby.core.prior.Uniform(1.19, 1.21)
non_roq_wfg = bilby.gw.WaveformGenerator(
- duration=self.duration, sampling_frequency=self.sampling_frequency,
+ duration=self.duration,
+ sampling_frequency=self.sampling_frequency,
frequency_domain_source_model=bilby.gw.source.lal_binary_black_hole,
waveform_arguments=dict(
- reference_frequency=20.0, minimum_frequency=20.0,
- approximant='IMRPhenomPv2'))
+ reference_frequency=20.0,
+ minimum_frequency=20.0,
+ approximant="IMRPhenomPv2",
+ ),
+ )
ifos.inject_signal(
- parameters=self.test_parameters, waveform_generator=non_roq_wfg)
+ parameters=self.test_parameters, waveform_generator=non_roq_wfg
+ )
self.ifos = ifos
roq_wfg = bilby.gw.waveform_generator.WaveformGenerator(
- duration=self.duration, sampling_frequency=self.sampling_frequency,
+ duration=self.duration,
+ sampling_frequency=self.sampling_frequency,
frequency_domain_source_model=bilby.gw.source.roq,
waveform_arguments=dict(
frequency_nodes_linear=fnodes_linear,
frequency_nodes_quadratic=fnodes_quadratic,
- reference_frequency=20., minimum_frequency=20.,
- approximant='IMRPhenomPv2'))
+ reference_frequency=20.0,
+ minimum_frequency=20.0,
+ approximant="IMRPhenomPv2",
+ ),
+ )
self.roq_wfg = roq_wfg
self.non_roq = bilby.gw.likelihood.GravitationalWaveTransient(
- interferometers=ifos, waveform_generator=non_roq_wfg)
+ interferometers=ifos, waveform_generator=non_roq_wfg
+ )
self.non_roq_phase = bilby.gw.likelihood.GravitationalWaveTransient(
- interferometers=ifos, waveform_generator=non_roq_wfg,
- phase_marginalization=True, priors=self.priors.copy())
+ interferometers=ifos,
+ waveform_generator=non_roq_wfg,
+ phase_marginalization=True,
+ priors=self.priors.copy(),
+ )
self.roq = bilby.gw.likelihood.ROQGravitationalWaveTransient(
- interferometers=ifos, waveform_generator=roq_wfg,
+ interferometers=ifos,
+ waveform_generator=roq_wfg,
linear_matrix=linear_matrix_file,
- quadratic_matrix=quadratic_matrix_file, priors=self.priors)
+ quadratic_matrix=quadratic_matrix_file,
+ priors=self.priors,
+ )
self.roq_phase = bilby.gw.likelihood.ROQGravitationalWaveTransient(
- interferometers=ifos, waveform_generator=roq_wfg,
+ interferometers=ifos,
+ waveform_generator=roq_wfg,
linear_matrix=linear_matrix_file,
quadratic_matrix=quadratic_matrix_file,
- phase_marginalization=True, priors=self.priors.copy())
+ phase_marginalization=True,
+ priors=self.priors.copy(),
+ )
def tearDown(self):
- del (self.roq, self.non_roq, self.non_roq_phase, self.roq_phase,
- self.ifos, self.priors)
+ del (
+ self.roq,
+ self.non_roq,
+ self.non_roq_phase,
+ self.roq_phase,
+ self.ifos,
+ self.priors,
+ )
def test_matches_non_roq(self):
self.non_roq.parameters.update(self.test_parameters)
self.roq.parameters.update(self.test_parameters)
self.assertLess(
- abs(self.non_roq.log_likelihood_ratio() -
- self.roq.log_likelihood_ratio()) /
- self.non_roq.log_likelihood_ratio(), 1e-3)
+ abs(self.non_roq.log_likelihood_ratio() - self.roq.log_likelihood_ratio())
+ / self.non_roq.log_likelihood_ratio(),
+ 1e-3,
+ )
def test_time_prior_out_of_bounds_returns_zero(self):
self.roq.parameters.update(self.test_parameters)
- self.roq.parameters['geocent_time'] = -5
- self.assertEqual(
- self.roq.log_likelihood_ratio(), np.nan_to_num(-np.inf))
+ self.roq.parameters["geocent_time"] = -5
+ self.assertEqual(self.roq.log_likelihood_ratio(), np.nan_to_num(-np.inf))
def test_phase_marginalisation_roq(self):
"""Test phase marginalised likelihood matches brute force version"""
self.non_roq_phase.parameters = self.test_parameters.copy()
self.roq_phase.parameters = self.test_parameters.copy()
self.assertLess(
- abs(self.non_roq_phase.log_likelihood_ratio() -
- self.roq_phase.log_likelihood_ratio()) /
- self.non_roq_phase.log_likelihood_ratio(), 1e-3)
+ abs(
+ self.non_roq_phase.log_likelihood_ratio()
+ - self.roq_phase.log_likelihood_ratio()
+ )
+ / self.non_roq_phase.log_likelihood_ratio(),
+ 1e-3,
+ )
def test_create_roq_weights_with_params(self):
roq = bilby.gw.likelihood.ROQGravitationalWaveTransient(
- interferometers=self.ifos, waveform_generator=self.roq_wfg,
- linear_matrix=self.linear_matrix_file, roq_params=self.params_file,
- quadratic_matrix=self.quadratic_matrix_file, priors=self.priors)
+ interferometers=self.ifos,
+ waveform_generator=self.roq_wfg,
+ linear_matrix=self.linear_matrix_file,
+ roq_params=self.params_file,
+ quadratic_matrix=self.quadratic_matrix_file,
+ priors=self.priors,
+ )
roq.parameters.update(self.test_parameters)
self.roq.parameters.update(self.test_parameters)
- self.assertEqual(
- roq.log_likelihood_ratio(), self.roq.log_likelihood_ratio())
+ self.assertEqual(roq.log_likelihood_ratio(), self.roq.log_likelihood_ratio())
def test_create_roq_weights_frequency_mismatch_works_with_params(self):
self.ifos[0].maximum_frequency = self.ifos[0].maximum_frequency / 2
bilby.gw.likelihood.ROQGravitationalWaveTransient(
- interferometers=self.ifos, waveform_generator=self.roq_wfg,
- linear_matrix=self.linear_matrix_file, roq_params=self.params_file,
- quadratic_matrix=self.quadratic_matrix_file, priors=self.priors)
+ interferometers=self.ifos,
+ waveform_generator=self.roq_wfg,
+ linear_matrix=self.linear_matrix_file,
+ roq_params=self.params_file,
+ quadratic_matrix=self.quadratic_matrix_file,
+ priors=self.priors,
+ )
def test_create_roq_weights_frequency_mismatch_fails_without_params(self):
self.ifos[0].maximum_frequency = self.ifos[0].maximum_frequency / 2
with self.assertRaises(ValueError):
bilby.gw.likelihood.ROQGravitationalWaveTransient(
- interferometers=self.ifos, waveform_generator=self.roq_wfg,
+ interferometers=self.ifos,
+ waveform_generator=self.roq_wfg,
linear_matrix=self.linear_matrix_file,
- quadratic_matrix=self.quadratic_matrix_file, priors=self.priors)
+ quadratic_matrix=self.quadratic_matrix_file,
+ priors=self.priors,
+ )
def test_create_roq_weights_fails_with_min_chirp_mass_outside_bounds(self):
self.ifos[0].maximum_frequency = self.ifos[0].maximum_frequency / 2
self.priors["chirp_mass"] = bilby.core.prior.Uniform(10, 45)
with self.assertRaises(BilbyROQParamsRangeError):
bilby.gw.likelihood.ROQGravitationalWaveTransient(
- interferometers=self.ifos, waveform_generator=self.roq_wfg,
+ interferometers=self.ifos,
+ waveform_generator=self.roq_wfg,
linear_matrix=self.linear_matrix_file,
roq_params=self.params_file,
quadratic_matrix=self.quadratic_matrix_file,
- priors=self.priors)
+ priors=self.priors,
+ )
def test_create_roq_weights_fails_with_max_chirp_mass_outside_bounds(self):
self.ifos[0].maximum_frequency = self.ifos[0].maximum_frequency / 2
self.priors["chirp_mass"] = bilby.core.prior.Uniform(12.299703, 50)
with self.assertRaises(BilbyROQParamsRangeError):
bilby.gw.likelihood.ROQGravitationalWaveTransient(
- interferometers=self.ifos, waveform_generator=self.roq_wfg,
+ interferometers=self.ifos,
+ waveform_generator=self.roq_wfg,
linear_matrix=self.linear_matrix_file,
roq_params=self.params_file,
quadratic_matrix=self.quadratic_matrix_file,
- priors=self.priors)
+ priors=self.priors,
+ )
def test_create_roq_weights_fails_with_min_component_mass_outside_bounds(self):
self.ifos[0].maximum_frequency = self.ifos[0].maximum_frequency / 2
@@ -700,57 +925,67 @@ class TestROQLikelihood(unittest.TestCase):
self.priors["mass_ratio"] = bilby.core.prior.Uniform(1e-5, 1)
with self.assertRaises(BilbyROQParamsRangeError):
bilby.gw.likelihood.ROQGravitationalWaveTransient(
- interferometers=self.ifos, waveform_generator=self.roq_wfg,
+ interferometers=self.ifos,
+ waveform_generator=self.roq_wfg,
linear_matrix=self.linear_matrix_file,
roq_params=self.params_file,
quadratic_matrix=self.quadratic_matrix_file,
- priors=self.priors)
+ priors=self.priors,
+ )
def test_create_roq_weights_fails_with_max_frequency(self):
- ifos = bilby.gw.detector.InterferometerList(['H1'])
+ ifos = bilby.gw.detector.InterferometerList(["H1"])
ifos.set_strain_data_from_power_spectral_densities(
- sampling_frequency=2**14, duration=4)
- ifos[0].maximum_frequency = 2**13
+ sampling_frequency=2 ** 14, duration=4
+ )
+ ifos[0].maximum_frequency = 2 ** 13
with self.assertRaises(BilbyROQParamsRangeError):
bilby.gw.likelihood.ROQGravitationalWaveTransient(
- interferometers=ifos, waveform_generator=self.roq_wfg,
+ interferometers=ifos,
+ waveform_generator=self.roq_wfg,
linear_matrix=self.linear_matrix_file,
roq_params=self.params_file,
quadratic_matrix=self.quadratic_matrix_file,
- priors=self.priors)
+ priors=self.priors,
+ )
def test_create_roq_weights_fails_due_to_min_frequency(self):
self.ifos[0].minimum_frequency = 15
with self.assertRaises(BilbyROQParamsRangeError):
bilby.gw.likelihood.ROQGravitationalWaveTransient(
- interferometers=self.ifos, waveform_generator=self.roq_wfg,
+ interferometers=self.ifos,
+ waveform_generator=self.roq_wfg,
linear_matrix=self.linear_matrix_file,
roq_params=self.params_file,
quadratic_matrix=self.quadratic_matrix_file,
- priors=self.priors)
+ priors=self.priors,
+ )
def test_create_roq_weights_fails_due_to_duration(self):
- ifos = bilby.gw.detector.InterferometerList(['H1'])
+ ifos = bilby.gw.detector.InterferometerList(["H1"])
ifos.set_strain_data_from_power_spectral_densities(
- sampling_frequency=self.sampling_frequency, duration=16)
+ sampling_frequency=self.sampling_frequency, duration=16
+ )
with self.assertRaises(BilbyROQParamsRangeError):
bilby.gw.likelihood.ROQGravitationalWaveTransient(
- interferometers=ifos, waveform_generator=self.roq_wfg,
+ interferometers=ifos,
+ waveform_generator=self.roq_wfg,
linear_matrix=self.linear_matrix_file,
roq_params=self.params_file,
quadratic_matrix=self.quadratic_matrix_file,
- priors=self.priors)
+ priors=self.priors,
+ )
class TestRescaledROQLikelihood(unittest.TestCase):
-
def test_rescaling(self):
# Possible locations for the ROQ: in the docker image, local, or on CIT
trial_roq_paths = [
"/roq_basis",
- os.path.join(os.path.expanduser("~"), 'ROQ_data/IMRPhenomPv2/4s'),
- "/home/cbc/ROQ_data/IMRPhenomPv2/4s"]
+ os.path.join(os.path.expanduser("~"), "ROQ_data/IMRPhenomPv2/4s"),
+ "/home/cbc/ROQ_data/IMRPhenomPv2/4s",
+ ]
roq_dir = None
for path in trial_roq_paths:
if os.path.isdir(path):
@@ -776,9 +1011,10 @@ class TestRescaledROQLikelihood(unittest.TestCase):
self.duration = 4 / scale_factor
self.sampling_frequency = 2048 * scale_factor
- ifos = bilby.gw.detector.InterferometerList(['H1'])
+ ifos = bilby.gw.detector.InterferometerList(["H1"])
ifos.set_strain_data_from_power_spectral_densities(
- sampling_frequency=self.sampling_frequency, duration=self.duration)
+ sampling_frequency=self.sampling_frequency, duration=self.duration
+ )
self.ifos = ifos
self.priors = bilby.gw.prior.BBHPriorDict()
@@ -786,38 +1022,45 @@ class TestRescaledROQLikelihood(unittest.TestCase):
self.priors.pop("mass_2")
# Testing is done with the 4s IMRPhenomPV2 ROQ basis
self.priors["chirp_mass"] = bilby.core.prior.Uniform(
- 12.299703 / scale_factor, 45 / scale_factor)
+ 12.299703 / scale_factor, 45 / scale_factor
+ )
self.priors["mass_ratio"] = bilby.core.prior.Uniform(0.125, 1)
- self.priors['geocent_time'] = bilby.core.prior.Uniform(1.19, 1.21)
+ self.priors["geocent_time"] = bilby.core.prior.Uniform(1.19, 1.21)
self.roq_wfg = bilby.gw.waveform_generator.WaveformGenerator(
- duration=self.duration, sampling_frequency=self.sampling_frequency,
+ duration=self.duration,
+ sampling_frequency=self.sampling_frequency,
frequency_domain_source_model=bilby.gw.source.roq,
waveform_arguments=dict(
frequency_nodes_linear=fnodes_linear,
frequency_nodes_quadratic=fnodes_quadratic,
- reference_frequency=20., minimum_frequency=20.,
- approximant='IMRPhenomPv2'))
+ reference_frequency=20.0,
+ minimum_frequency=20.0,
+ approximant="IMRPhenomPv2",
+ ),
+ )
self.roq = bilby.gw.likelihood.ROQGravitationalWaveTransient(
- interferometers=ifos, waveform_generator=self.roq_wfg,
- linear_matrix=linear_matrix_file, roq_params=params,
- roq_scale_factor=scale_factor, quadratic_matrix=quadratic_matrix_file,
- priors=self.priors)
+ interferometers=ifos,
+ waveform_generator=self.roq_wfg,
+ linear_matrix=linear_matrix_file,
+ roq_params=params,
+ roq_scale_factor=scale_factor,
+ quadratic_matrix=quadratic_matrix_file,
+ priors=self.priors,
+ )
class TestBBHLikelihoodSetUp(unittest.TestCase):
-
def setUp(self):
- self.ifos = bilby.gw.detector.InterferometerList(['H1'])
+ self.ifos = bilby.gw.detector.InterferometerList(["H1"])
def tearDown(self):
del self.ifos
def test_instantiation(self):
- self.like = bilby.gw.likelihood.get_binary_black_hole_likelihood(
- self.ifos)
+ self.like = bilby.gw.likelihood.get_binary_black_hole_likelihood(self.ifos)
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/gw_plot_test.py b/test/gw_plot_test.py
index b440f2eb8136335a6daaf326cf8283d99e497fad..336bdd73bf651e5187b13e03059e20ceb3296829 100644
--- a/test/gw_plot_test.py
+++ b/test/gw_plot_test.py
@@ -8,11 +8,10 @@ import bilby
class TestCBCResult(unittest.TestCase):
-
def setUp(self):
bilby.utils.command_line_args.bilby_test_mode = False
priors = bilby.gw.prior.BBHPriorDict()
- priors['geocent_time'] = 2
+ priors["geocent_time"] = 2
injection_parameters = priors.sample()
self.meta_data = dict(
likelihood=dict(
@@ -21,11 +20,12 @@ class TestCBCResult(unittest.TestCase):
time_marginalization=True,
frequency_domain_source_model=bilby.gw.source.lal_binary_black_hole,
waveform_arguments=dict(
- reference_frequency=20.0,
- waveform_approximant='IMRPhenomPv2'),
+ reference_frequency=20.0, waveform_approximant="IMRPhenomPv2"
+ ),
interferometers=dict(
H1=dict(optimal_SNR=1, parameters=injection_parameters),
- L1=dict(optimal_SNR=1, parameters=injection_parameters)),
+ L1=dict(optimal_SNR=1, parameters=injection_parameters),
+ ),
sampling_frequency=4096,
duration=4,
start_time=0,
@@ -34,12 +34,16 @@ class TestCBCResult(unittest.TestCase):
)
)
self.result = bilby.gw.result.CBCResult(
- label='label', outdir='outdir', sampler='nestle',
- search_parameter_keys=list(priors.keys()), fixed_parameter_keys=list(),
- priors=priors, sampler_kwargs=dict(test='test', func=lambda x: x),
+ label="label",
+ outdir="outdir",
+ sampler="nestle",
+ search_parameter_keys=list(priors.keys()),
+ fixed_parameter_keys=list(),
+ priors=priors,
+ sampler_kwargs=dict(test="test", func=lambda x: x),
injection_parameters=injection_parameters,
meta_data=self.meta_data,
- posterior=pd.DataFrame(priors.sample(100))
+ posterior=pd.DataFrame(priors.sample(100)),
)
if not os.path.isdir(self.result.outdir):
os.mkdir(self.result.outdir)
@@ -63,7 +67,9 @@ class TestCBCResult(unittest.TestCase):
label="recalib_H1_",
n_nodes=5,
)
- calibration_filename = f"{self.result.outdir}/{self.result.label}_calibration.png"
+ calibration_filename = (
+ f"{self.result.outdir}/{self.result.label}_calibration.png"
+ )
for key in calibration_prior:
self.result.posterior[key] = calibration_prior[key].sample(100)
self.result.plot_calibration_posterior()
@@ -71,7 +77,9 @@ class TestCBCResult(unittest.TestCase):
def test_calibration_plot_returns_none_with_no_calibration_parameters(self):
self.assertIsNone(self.result.plot_calibration_posterior())
- calibration_filename = f"{self.result.outdir}/{self.result.label}_calibration.png"
+ calibration_filename = (
+ f"{self.result.outdir}/{self.result.label}_calibration.png"
+ )
self.assertFalse(os.path.exists(calibration_filename))
def test_calibration_pdf_plot(self):
@@ -83,7 +91,9 @@ class TestCBCResult(unittest.TestCase):
label="recalib_H1_",
n_nodes=5,
)
- calibration_filename = f"{self.result.outdir}/{self.result.label}_calibration.pdf"
+ calibration_filename = (
+ f"{self.result.outdir}/{self.result.label}_calibration.pdf"
+ )
for key in calibration_prior:
self.result.posterior[key] = calibration_prior[key].sample(100)
self.result.plot_calibration_posterior(format="pdf")
@@ -96,20 +106,31 @@ class TestCBCResult(unittest.TestCase):
def test_waveform_plotting_png(self):
self.result.plot_waveform_posterior(n_samples=200)
for ifo in self.result.interferometers:
- self.assertTrue(os.path.exists(
- f"{self.result.outdir}/{self.result.label}_{ifo}_waveform.png")
+ self.assertTrue(
+ os.path.exists(
+ f"{self.result.outdir}/{self.result.label}_{ifo}_waveform.png"
+ )
)
def test_plot_skymap_meta_data(self):
from ligo.skymap import io
+
expected_keys = {
- "HISTORY", "build_date", "creator", "distmean", "diststd",
- "gps_creation_time", "gps_time", "nest", "objid", "origin",
- "vcs_revision", "vcs_version", "instruments"
+ "HISTORY",
+ "build_date",
+ "creator",
+ "distmean",
+ "diststd",
+ "gps_creation_time",
+ "gps_time",
+ "nest",
+ "objid",
+ "origin",
+ "vcs_revision",
+ "vcs_version",
+ "instruments",
}
- self.result.plot_skymap(
- maxpts=50, geo=False, objid="test", instruments="H1L1"
- )
+ self.result.plot_skymap(maxpts=50, geo=False, objid="test", instruments="H1L1")
fits_filename = f"{self.result.outdir}/{self.result.label}_skymap.fits"
skymap_filename = f"{self.result.outdir}/{self.result.label}_skymap.png"
pickle_filename = f"{self.result.outdir}/{self.result.label}_skypost.obj"
@@ -118,10 +139,14 @@ class TestCBCResult(unittest.TestCase):
self.assertTrue(os.path.exists(skymap_filename))
self.assertTrue(os.path.exists(pickle_filename))
self.result.plot_skymap(
- maxpts=50, geo=False, objid="test", instruments="H1L1",
- load_pickle=True, colorbar=True
+ maxpts=50,
+ geo=False,
+ objid="test",
+ instruments="H1L1",
+ load_pickle=True,
+ colorbar=True,
)
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/gw_prior_test.py b/test/gw_prior_test.py
index 28bbaf1da3b6beb9e17564d847ede0072720f965..fb45d589ad35b6c44d73c13f1bdd0c5f65e9183f 100644
--- a/test/gw_prior_test.py
+++ b/test/gw_prior_test.py
@@ -18,14 +18,15 @@ from bilby.gw import conversion
class TestBBHPriorDict(unittest.TestCase):
-
def setUp(self):
self.prior_dict = dict()
- self.base_directory =\
- '/'.join(os.path.dirname(
- os.path.abspath(sys.argv[0])).split('/')[:-1])
- self.filename = os.path.join(os.path.dirname(os.path.realpath(__file__)),
- 'prior_files/binary_black_holes.prior')
+ self.base_directory = "/".join(
+ os.path.dirname(os.path.abspath(sys.argv[0])).split("/")[:-1]
+ )
+ self.filename = os.path.join(
+ os.path.dirname(os.path.realpath(__file__)),
+ "prior_files/binary_black_holes.prior",
+ )
self.bbh_prior_dict = bilby.gw.prior.BBHPriorDict(filename=self.filename)
for key, value in self.bbh_prior_dict.items():
self.prior_dict[key] = value
@@ -38,14 +39,30 @@ class TestBBHPriorDict(unittest.TestCase):
def test_create_default_prior(self):
default = bilby.gw.prior.BBHPriorDict()
- minima = all([self.bbh_prior_dict[key].minimum == default[key].minimum
- for key in default.keys()])
- maxima = all([self.bbh_prior_dict[key].maximum == default[key].maximum
- for key in default.keys()])
- names = all([self.bbh_prior_dict[key].name == default[key].name
- for key in default.keys()])
- boundaries = all([self.bbh_prior_dict[key].boundary == default[key].boundary
- for key in default.keys()])
+ minima = all(
+ [
+ self.bbh_prior_dict[key].minimum == default[key].minimum
+ for key in default.keys()
+ ]
+ )
+ maxima = all(
+ [
+ self.bbh_prior_dict[key].maximum == default[key].maximum
+ for key in default.keys()
+ ]
+ )
+ names = all(
+ [
+ self.bbh_prior_dict[key].name == default[key].name
+ for key in default.keys()
+ ]
+ )
+ boundaries = all(
+ [
+ self.bbh_prior_dict[key].boundary == default[key].boundary
+ for key in default.keys()
+ ]
+ )
self.assertTrue(all([minima, maxima, names, boundaries]))
@@ -55,71 +72,101 @@ class TestBBHPriorDict(unittest.TestCase):
self.assertEqual(self.bbh_prior_dict[key], new_dict[key])
def test_redundant_priors_not_in_dict_before(self):
- for prior in ['chirp_mass', 'total_mass', 'mass_ratio', 'symmetric_mass_ratio',
- 'cos_tilt_1', 'cos_tilt_2', 'phi_1', 'phi_2', 'cos_theta_jn',
- 'comoving_distance', 'redshift']:
+ for prior in [
+ "chirp_mass",
+ "total_mass",
+ "mass_ratio",
+ "symmetric_mass_ratio",
+ "cos_tilt_1",
+ "cos_tilt_2",
+ "phi_1",
+ "phi_2",
+ "cos_theta_jn",
+ "comoving_distance",
+ "redshift",
+ ]:
self.assertTrue(self.bbh_prior_dict.test_redundancy(prior))
def test_redundant_priors_already_in_dict(self):
- for prior in ['mass_1', 'mass_2', 'tilt_1', 'tilt_2',
- 'phi_1', 'phi_2', 'theta_jn', 'luminosity_distance']:
+ for prior in [
+ "mass_1",
+ "mass_2",
+ "tilt_1",
+ "tilt_2",
+ "phi_1",
+ "phi_2",
+ "theta_jn",
+ "luminosity_distance",
+ ]:
self.assertTrue(self.bbh_prior_dict.test_redundancy(prior))
def test_correct_not_redundant_priors_masses(self):
- del self.bbh_prior_dict['mass_2']
- for prior in ['mass_2', 'chirp_mass', 'total_mass', 'symmetric_mass_ratio']:
+ del self.bbh_prior_dict["mass_2"]
+ for prior in ["mass_2", "chirp_mass", "total_mass", "symmetric_mass_ratio"]:
self.assertFalse(self.bbh_prior_dict.test_redundancy(prior))
def test_correct_not_redundant_priors_spin_magnitudes(self):
- del self.bbh_prior_dict['a_2']
- self.assertFalse(self.bbh_prior_dict.test_redundancy('a_2'))
+ del self.bbh_prior_dict["a_2"]
+ self.assertFalse(self.bbh_prior_dict.test_redundancy("a_2"))
def test_correct_not_redundant_priors_spin_tilt_1(self):
- del self.bbh_prior_dict['tilt_1']
- for prior in ['tilt_1', 'cos_tilt_1']:
+ del self.bbh_prior_dict["tilt_1"]
+ for prior in ["tilt_1", "cos_tilt_1"]:
self.assertFalse(self.bbh_prior_dict.test_redundancy(prior))
def test_correct_not_redundant_priors_spin_tilt_2(self):
- del self.bbh_prior_dict['tilt_2']
- for prior in ['tilt_2', 'cos_tilt_2']:
+ del self.bbh_prior_dict["tilt_2"]
+ for prior in ["tilt_2", "cos_tilt_2"]:
self.assertFalse(self.bbh_prior_dict.test_redundancy(prior))
def test_correct_not_redundant_priors_spin_azimuth(self):
- del self.bbh_prior_dict['phi_12']
- for prior in ['phi_1', 'phi_2', 'phi_12']:
+ del self.bbh_prior_dict["phi_12"]
+ for prior in ["phi_1", "phi_2", "phi_12"]:
self.assertFalse(self.bbh_prior_dict.test_redundancy(prior))
def test_correct_not_redundant_priors_inclination(self):
- del self.bbh_prior_dict['theta_jn']
- for prior in ['theta_jn', 'cos_theta_jn']:
+ del self.bbh_prior_dict["theta_jn"]
+ for prior in ["theta_jn", "cos_theta_jn"]:
self.assertFalse(self.bbh_prior_dict.test_redundancy(prior))
def test_correct_not_redundant_priors_distance(self):
- del self.bbh_prior_dict['luminosity_distance']
- for prior in ['luminosity_distance', 'comoving_distance',
- 'redshift']:
+ del self.bbh_prior_dict["luminosity_distance"]
+ for prior in ["luminosity_distance", "comoving_distance", "redshift"]:
self.assertFalse(self.bbh_prior_dict.test_redundancy(prior))
def test_add_unrelated_prior(self):
- self.assertFalse(self.bbh_prior_dict.test_redundancy('abc'))
+ self.assertFalse(self.bbh_prior_dict.test_redundancy("abc"))
def test_test_has_redundant_priors(self):
self.assertFalse(self.bbh_prior_dict.test_has_redundant_keys())
- for prior in ['chirp_mass', 'total_mass', 'mass_ratio', 'symmetric_mass_ratio',
- 'cos_tilt_1', 'cos_tilt_2', 'phi_1', 'phi_2', 'cos_theta_jn',
- 'comoving_distance', 'redshift']:
+ for prior in [
+ "chirp_mass",
+ "total_mass",
+ "mass_ratio",
+ "symmetric_mass_ratio",
+ "cos_tilt_1",
+ "cos_tilt_2",
+ "phi_1",
+ "phi_2",
+ "cos_theta_jn",
+ "comoving_distance",
+ "redshift",
+ ]:
self.bbh_prior_dict[prior] = 0
self.assertTrue(self.bbh_prior_dict.test_has_redundant_keys())
del self.bbh_prior_dict[prior]
def test_add_constraint_prior_not_redundant(self):
- self.bbh_prior_dict['chirp_mass'] = bilby.prior.Constraint(
- minimum=20, maximum=40, name='chirp_mass')
+ self.bbh_prior_dict["chirp_mass"] = bilby.prior.Constraint(
+ minimum=20, maximum=40, name="chirp_mass"
+ )
self.assertFalse(self.bbh_prior_dict.test_has_redundant_keys())
def test_pickle_prior(self):
- priors = dict(chirp_mass=bilby.core.prior.Uniform(10, 20),
- mass_ratio=bilby.core.prior.Uniform(0.125, 1))
+ priors = dict(
+ chirp_mass=bilby.core.prior.Uniform(10, 20),
+ mass_ratio=bilby.core.prior.Uniform(0.125, 1),
+ )
priors = bilby.gw.prior.BBHPriorDict(priors)
with open("test.pickle", "wb") as file:
pickle.dump(priors, file)
@@ -129,29 +176,43 @@ class TestBBHPriorDict(unittest.TestCase):
class TestPriorConversion(unittest.TestCase):
-
def test_bilby_to_lalinference(self):
mass_1 = [1, 20]
mass_2 = [1, 20]
chirp_mass = [1, 5]
mass_ratio = [0.125, 1]
- bilby_prior = BBHPriorDict(dictionary=dict(
- chirp_mass=Uniform(name='chirp_mass', minimum=chirp_mass[0], maximum=chirp_mass[1]),
- mass_ratio=Uniform(name='mass_ratio', minimum=mass_ratio[0], maximum=mass_ratio[1]),
- mass_2=Constraint(name='mass_2', minimum=mass_1[0], maximum=mass_1[1]),
- mass_1=Constraint(name='mass_1', minimum=mass_2[0], maximum=mass_2[1])))
-
- lalinf_prior = BBHPriorDict(dictionary=dict(
- mass_ratio=Constraint(name='mass_ratio', minimum=mass_ratio[0], maximum=mass_ratio[1]),
- chirp_mass=Constraint(name='chirp_mass', minimum=chirp_mass[0], maximum=chirp_mass[1]),
- mass_2=Uniform(name='mass_2', minimum=mass_1[0], maximum=mass_1[1]),
- mass_1=Uniform(name='mass_1', minimum=mass_2[0], maximum=mass_2[1])))
+ bilby_prior = BBHPriorDict(
+ dictionary=dict(
+ chirp_mass=Uniform(
+ name="chirp_mass", minimum=chirp_mass[0], maximum=chirp_mass[1]
+ ),
+ mass_ratio=Uniform(
+ name="mass_ratio", minimum=mass_ratio[0], maximum=mass_ratio[1]
+ ),
+ mass_2=Constraint(name="mass_2", minimum=mass_1[0], maximum=mass_1[1]),
+ mass_1=Constraint(name="mass_1", minimum=mass_2[0], maximum=mass_2[1]),
+ )
+ )
+
+ lalinf_prior = BBHPriorDict(
+ dictionary=dict(
+ mass_ratio=Constraint(
+ name="mass_ratio", minimum=mass_ratio[0], maximum=mass_ratio[1]
+ ),
+ chirp_mass=Constraint(
+ name="chirp_mass", minimum=chirp_mass[0], maximum=chirp_mass[1]
+ ),
+ mass_2=Uniform(name="mass_2", minimum=mass_1[0], maximum=mass_1[1]),
+ mass_1=Uniform(name="mass_1", minimum=mass_2[0], maximum=mass_2[1]),
+ )
+ )
nsamples = 5000
bilby_samples = bilby_prior.sample(nsamples)
bilby_samples, _ = conversion.convert_to_lal_binary_black_hole_parameters(
- bilby_samples)
+ bilby_samples
+ )
# Quicker way to generate LA prior samples (rather than specifying Constraint)
lalinf_samples = []
@@ -162,7 +223,9 @@ class TestPriorConversion(unittest.TestCase):
if s["mass_2"] / s["mass_1"] > 0.125:
lalinf_samples.append(s)
lalinf_samples = pd.DataFrame(lalinf_samples)
- lalinf_samples["mass_ratio"] = lalinf_samples["mass_2"] / lalinf_samples["mass_1"]
+ lalinf_samples["mass_ratio"] = (
+ lalinf_samples["mass_2"] / lalinf_samples["mass_1"]
+ )
# Construct fake result object
result = bilby.core.result.Result()
@@ -170,12 +233,19 @@ class TestPriorConversion(unittest.TestCase):
result.meta_data = dict()
result.priors = bilby_prior
result.posterior = pd.DataFrame(bilby_samples)
- result_converted = bilby.gw.prior.convert_to_flat_in_component_mass_prior(result)
+ result_converted = bilby.gw.prior.convert_to_flat_in_component_mass_prior(
+ result
+ )
if "plot" in sys.argv:
# Useful for debugging
plt.hist(bilby_samples["mass_ratio"], bins=50, density=True, alpha=0.5)
- plt.hist(result_converted.posterior["mass_ratio"], bins=50, density=True, alpha=0.5)
+ plt.hist(
+ result_converted.posterior["mass_ratio"],
+ bins=50,
+ density=True,
+ alpha=0.5,
+ )
plt.hist(lalinf_samples["mass_ratio"], bins=50, alpha=0.5, density=True)
plt.show()
@@ -185,7 +255,9 @@ class TestPriorConversion(unittest.TestCase):
self.assertFalse(ks.pvalue > 0.05)
# Check that the non-reweighted posteriors pass a KS test
- ks = ks_2samp(result_converted.posterior["mass_ratio"], lalinf_samples["mass_ratio"])
+ ks = ks_2samp(
+ result_converted.posterior["mass_ratio"], lalinf_samples["mass_ratio"]
+ )
print("Reweighted KS test = ", ks)
self.assertTrue(ks.pvalue > 0.001)
@@ -194,37 +266,38 @@ class TestPackagedPriors(unittest.TestCase):
""" Test that the prepackaged priors load """
def test_aligned(self):
- filename = 'aligned_spin_binary_black_holes.prior'
+ filename = "aligned_spin_binary_black_holes.prior"
prior_dict = bilby.gw.prior.BBHPriorDict(filename=filename)
- self.assertTrue('chi_1' in prior_dict)
- self.assertTrue('chi_2' in prior_dict)
+ self.assertTrue("chi_1" in prior_dict)
+ self.assertTrue("chi_2" in prior_dict)
def test_precessing(self):
- filename = 'precessing_binary_neutron_stars.prior'
+ filename = "precessing_binary_neutron_stars.prior"
prior_dict = bilby.gw.prior.BBHPriorDict(filename=filename)
- self.assertTrue('lambda_1' in prior_dict)
- self.assertTrue('lambda_2' in prior_dict)
+ self.assertTrue("lambda_1" in prior_dict)
+ self.assertTrue("lambda_2" in prior_dict)
def test_binary_black_holes(self):
- filename = 'binary_black_holes.prior'
+ filename = "binary_black_holes.prior"
prior_dict = bilby.gw.prior.BBHPriorDict(filename=filename)
- self.assertTrue('a_1' in prior_dict)
+ self.assertTrue("a_1" in prior_dict)
def test_binary_neutron_stars(self):
- filename = 'binary_neutron_stars.prior'
+ filename = "binary_neutron_stars.prior"
prior_dict = bilby.gw.prior.BNSPriorDict(filename=filename)
- self.assertTrue('lambda_1' in prior_dict)
+ self.assertTrue("lambda_1" in prior_dict)
class TestBNSPriorDict(unittest.TestCase):
-
def setUp(self):
self.prior_dict = OrderedDict()
- self.base_directory =\
- '/'.join(os.path.dirname(
- os.path.abspath(sys.argv[0])).split('/')[:-1])
- self.filename = os.path.join(os.path.dirname(os.path.realpath(__file__)),
- 'prior_files/binary_neutron_stars.prior')
+ self.base_directory = "/".join(
+ os.path.dirname(os.path.abspath(sys.argv[0])).split("/")[:-1]
+ )
+ self.filename = os.path.join(
+ os.path.dirname(os.path.realpath(__file__)),
+ "prior_files/binary_neutron_stars.prior",
+ )
self.bns_prior_dict = bilby.gw.prior.BNSPriorDict(filename=self.filename)
for key, value in self.bns_prior_dict.items():
self.prior_dict[key] = value
@@ -237,14 +310,30 @@ class TestBNSPriorDict(unittest.TestCase):
def test_create_default_prior(self):
default = bilby.gw.prior.BNSPriorDict()
- minima = all([self.bns_prior_dict[key].minimum == default[key].minimum
- for key in default.keys()])
- maxima = all([self.bns_prior_dict[key].maximum == default[key].maximum
- for key in default.keys()])
- names = all([self.bns_prior_dict[key].name == default[key].name
- for key in default.keys()])
- boundaries = all([self.bns_prior_dict[key].boundary == default[key].boundary
- for key in default.keys()])
+ minima = all(
+ [
+ self.bns_prior_dict[key].minimum == default[key].minimum
+ for key in default.keys()
+ ]
+ )
+ maxima = all(
+ [
+ self.bns_prior_dict[key].maximum == default[key].maximum
+ for key in default.keys()
+ ]
+ )
+ names = all(
+ [
+ self.bns_prior_dict[key].name == default[key].name
+ for key in default.keys()
+ ]
+ )
+ boundaries = all(
+ [
+ self.bns_prior_dict[key].boundary == default[key].boundary
+ for key in default.keys()
+ ]
+ )
self.assertTrue(all([minima, maxima, names, boundaries]))
@@ -253,61 +342,82 @@ class TestBNSPriorDict(unittest.TestCase):
self.assertDictEqual(self.bns_prior_dict, new_dict)
def test_redundant_priors_not_in_dict_before(self):
- for prior in ['chirp_mass', 'total_mass', 'mass_ratio',
- 'symmetric_mass_ratio', 'cos_theta_jn', 'comoving_distance',
- 'redshift', 'lambda_tilde', 'delta_lambda_tilde']:
+ for prior in [
+ "chirp_mass",
+ "total_mass",
+ "mass_ratio",
+ "symmetric_mass_ratio",
+ "cos_theta_jn",
+ "comoving_distance",
+ "redshift",
+ "lambda_tilde",
+ "delta_lambda_tilde",
+ ]:
self.assertTrue(self.bns_prior_dict.test_redundancy(prior))
def test_redundant_priors_already_in_dict(self):
- for prior in ['mass_1', 'mass_2', 'chi_1', 'chi_2',
- 'theta_jn', 'luminosity_distance',
- 'lambda_1', 'lambda_2']:
+ for prior in [
+ "mass_1",
+ "mass_2",
+ "chi_1",
+ "chi_2",
+ "theta_jn",
+ "luminosity_distance",
+ "lambda_1",
+ "lambda_2",
+ ]:
self.assertTrue(self.bns_prior_dict.test_redundancy(prior))
def test_correct_not_redundant_priors_masses(self):
- del self.bns_prior_dict['mass_2']
- for prior in ['mass_2', 'chirp_mass', 'total_mass', 'symmetric_mass_ratio']:
+ del self.bns_prior_dict["mass_2"]
+ for prior in ["mass_2", "chirp_mass", "total_mass", "symmetric_mass_ratio"]:
self.assertFalse(self.bns_prior_dict.test_redundancy(prior))
def test_correct_not_redundant_priors_spin_magnitudes(self):
- del self.bns_prior_dict['chi_2']
- self.assertFalse(self.bns_prior_dict.test_redundancy('chi_2'))
+ del self.bns_prior_dict["chi_2"]
+ self.assertFalse(self.bns_prior_dict.test_redundancy("chi_2"))
def test_correct_not_redundant_priors_inclination(self):
- del self.bns_prior_dict['theta_jn']
- for prior in ['theta_jn', 'cos_theta_jn']:
+ del self.bns_prior_dict["theta_jn"]
+ for prior in ["theta_jn", "cos_theta_jn"]:
self.assertFalse(self.bns_prior_dict.test_redundancy(prior))
def test_correct_not_redundant_priors_distance(self):
- del self.bns_prior_dict['luminosity_distance']
- for prior in ['luminosity_distance', 'comoving_distance',
- 'redshift']:
+ del self.bns_prior_dict["luminosity_distance"]
+ for prior in ["luminosity_distance", "comoving_distance", "redshift"]:
self.assertFalse(self.bns_prior_dict.test_redundancy(prior))
def test_correct_not_redundant_priors_tidal(self):
- del self.bns_prior_dict['lambda_1']
- for prior in['lambda_1', 'lambda_tilde', 'delta_lambda_tilde']:
+ del self.bns_prior_dict["lambda_1"]
+ for prior in ["lambda_1", "lambda_tilde", "delta_lambda_tilde"]:
self.assertFalse(self.bns_prior_dict.test_redundancy(prior))
def test_add_unrelated_prior(self):
- self.assertFalse(self.bns_prior_dict.test_redundancy('abc'))
+ self.assertFalse(self.bns_prior_dict.test_redundancy("abc"))
def test_test_has_redundant_priors(self):
self.assertFalse(self.bns_prior_dict.test_has_redundant_keys())
- for prior in ['chirp_mass', 'total_mass', 'mass_ratio', 'symmetric_mass_ratio',
- 'cos_theta_jn', 'comoving_distance', 'redshift']:
+ for prior in [
+ "chirp_mass",
+ "total_mass",
+ "mass_ratio",
+ "symmetric_mass_ratio",
+ "cos_theta_jn",
+ "comoving_distance",
+ "redshift",
+ ]:
self.bns_prior_dict[prior] = 0
self.assertTrue(self.bns_prior_dict.test_has_redundant_keys())
del self.bns_prior_dict[prior]
def test_add_constraint_prior_not_redundant(self):
- self.bns_prior_dict['chirp_mass'] = bilby.prior.Constraint(
- minimum=1, maximum=2, name='chirp_mass')
+ self.bns_prior_dict["chirp_mass"] = bilby.prior.Constraint(
+ minimum=1, maximum=2, name="chirp_mass"
+ )
self.assertFalse(self.bns_prior_dict.test_has_redundant_keys())
class TestCalibrationPrior(unittest.TestCase):
-
def setUp(self):
self.minimum_frequency = 20
self.maximum_frequency = 1024
@@ -317,81 +427,92 @@ class TestCalibrationPrior(unittest.TestCase):
amplitude_sigma = 0.1
phase_sigma = 0.1
n_nodes = 9
- label = 'test'
+ label = "test"
test = bilby.gw.prior.CalibrationPriorDict.constant_uncertainty_spline(
- amplitude_sigma, phase_sigma, self.minimum_frequency,
- self.maximum_frequency, n_nodes, label)
+ amplitude_sigma,
+ phase_sigma,
+ self.minimum_frequency,
+ self.maximum_frequency,
+ n_nodes,
+ label,
+ )
self.assertEqual(len(test), n_nodes * 3)
class TestUniformComovingVolumePrior(unittest.TestCase):
-
def setUp(self):
pass
def test_minimum(self):
prior = bilby.gw.prior.UniformComovingVolume(
- minimum=10, maximum=10000, name='luminosity_distance')
+ minimum=10, maximum=10000, name="luminosity_distance"
+ )
self.assertEqual(prior.minimum, 10)
def test_maximum(self):
prior = bilby.gw.prior.UniformComovingVolume(
- minimum=10, maximum=10000, name='luminosity_distance')
+ minimum=10, maximum=10000, name="luminosity_distance"
+ )
self.assertEqual(prior.maximum, 10000)
def test_zero_minimum_works(self):
prior = bilby.gw.prior.UniformComovingVolume(
- minimum=0, maximum=10000, name='luminosity_distance')
+ minimum=0, maximum=10000, name="luminosity_distance"
+ )
self.assertEqual(prior.minimum, 0)
def test_specify_cosmology(self):
prior = bilby.gw.prior.UniformComovingVolume(
- minimum=10, maximum=10000, name='luminosity_distance',
- cosmology='Planck13')
+ minimum=10, maximum=10000, name="luminosity_distance", cosmology="Planck13"
+ )
self.assertEqual(repr(prior.cosmology), repr(cosmology.Planck13))
def test_comoving_prior_creation(self):
prior = bilby.gw.prior.UniformComovingVolume(
- minimum=10, maximum=1000, name='comoving_distance')
- self.assertEqual(prior.latex_label, '$d_C$')
+ minimum=10, maximum=1000, name="comoving_distance"
+ )
+ self.assertEqual(prior.latex_label, "$d_C$")
def test_redshift_prior_creation(self):
prior = bilby.gw.prior.UniformComovingVolume(
- minimum=0.1, maximum=1, name='redshift')
- self.assertEqual(prior.latex_label, '$z$')
+ minimum=0.1, maximum=1, name="redshift"
+ )
+ self.assertEqual(prior.latex_label, "$z$")
def test_redshift_to_luminosity_distance(self):
prior = bilby.gw.prior.UniformComovingVolume(
- minimum=0.1, maximum=1, name='redshift')
- new_prior = prior.get_corresponding_prior('luminosity_distance')
- self.assertEqual(new_prior.name, 'luminosity_distance')
+ minimum=0.1, maximum=1, name="redshift"
+ )
+ new_prior = prior.get_corresponding_prior("luminosity_distance")
+ self.assertEqual(new_prior.name, "luminosity_distance")
def test_luminosity_distance_to_redshift(self):
prior = bilby.gw.prior.UniformComovingVolume(
- minimum=10, maximum=10000, name='luminosity_distance')
- new_prior = prior.get_corresponding_prior('redshift')
- self.assertEqual(new_prior.name, 'redshift')
+ minimum=10, maximum=10000, name="luminosity_distance"
+ )
+ new_prior = prior.get_corresponding_prior("redshift")
+ self.assertEqual(new_prior.name, "redshift")
def test_luminosity_distance_to_comoving_distance(self):
prior = bilby.gw.prior.UniformComovingVolume(
- minimum=10, maximum=10000, name='luminosity_distance')
- new_prior = prior.get_corresponding_prior('comoving_distance')
- self.assertEqual(new_prior.name, 'comoving_distance')
+ minimum=10, maximum=10000, name="luminosity_distance"
+ )
+ new_prior = prior.get_corresponding_prior("comoving_distance")
+ self.assertEqual(new_prior.name, "comoving_distance")
class TestAlignedSpin(unittest.TestCase):
-
def setUp(self):
pass
def test_default_prior_matches_analytic(self):
prior = bilby.gw.prior.AlignedSpin()
chis = np.linspace(-1, 1, 20)
- analytic = - np.log(np.abs(chis)) / 2
+ analytic = -np.log(np.abs(chis)) / 2
max_difference = max(abs(analytic - prior.prob(chis)))
self.assertAlmostEqual(max_difference, 0, 2)
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/gw_result_test.py b/test/gw_result_test.py
index 4c6c64fac62bea842a72ed942c4e80586c79dc95..12b30cd21de10cc28e6d7f47734d84d84b6d827c 100644
--- a/test/gw_result_test.py
+++ b/test/gw_result_test.py
@@ -8,11 +8,10 @@ import bilby
class TestCBCResult(unittest.TestCase):
-
def setUp(self):
bilby.utils.command_line_args.bilby_test_mode = False
priors = bilby.gw.prior.BBHPriorDict()
- priors['geocent_time'] = 2
+ priors["geocent_time"] = 2
injection_parameters = priors.sample()
self.meta_data = dict(
likelihood=dict(
@@ -21,11 +20,12 @@ class TestCBCResult(unittest.TestCase):
time_marginalization=True,
frequency_domain_source_model=bilby.gw.source.lal_binary_black_hole,
waveform_arguments=dict(
- reference_frequency=20.0,
- waveform_approximant='IMRPhenomPv2'),
+ reference_frequency=20.0, waveform_approximant="IMRPhenomPv2"
+ ),
interferometers=dict(
H1=dict(optimal_SNR=1, parameters=injection_parameters),
- L1=dict(optimal_SNR=1, parameters=injection_parameters)),
+ L1=dict(optimal_SNR=1, parameters=injection_parameters),
+ ),
sampling_frequency=4096,
duration=4,
start_time=0,
@@ -34,12 +34,16 @@ class TestCBCResult(unittest.TestCase):
)
)
self.result = bilby.gw.result.CBCResult(
- label='label', outdir='outdir', sampler='nestle',
- search_parameter_keys=list(priors.keys()), fixed_parameter_keys=list(),
- priors=priors, sampler_kwargs=dict(test='test', func=lambda x: x),
+ label="label",
+ outdir="outdir",
+ sampler="nestle",
+ search_parameter_keys=list(priors.keys()),
+ fixed_parameter_keys=list(),
+ priors=priors,
+ sampler_kwargs=dict(test="test", func=lambda x: x),
injection_parameters=injection_parameters,
meta_data=self.meta_data,
- posterior=pd.DataFrame(priors.sample(100))
+ posterior=pd.DataFrame(priors.sample(100)),
)
if not os.path.isdir(self.result.outdir):
os.mkdir(self.result.outdir)
@@ -57,133 +61,147 @@ class TestCBCResult(unittest.TestCase):
def test_phase_marginalization(self):
self.assertEqual(
self.result.phase_marginalization,
- self.meta_data['likelihood']['phase_marginalization'])
+ self.meta_data["likelihood"]["phase_marginalization"],
+ )
def test_phase_marginalization_unset(self):
- self.result.meta_data['likelihood'].pop('phase_marginalization')
+ self.result.meta_data["likelihood"].pop("phase_marginalization")
with self.assertRaises(AttributeError):
self.result.phase_marginalization
def test_time_marginalization(self):
self.assertEqual(
self.result.time_marginalization,
- self.meta_data['likelihood']['time_marginalization'])
+ self.meta_data["likelihood"]["time_marginalization"],
+ )
def test_time_marginalization_unset(self):
- self.result.meta_data['likelihood'].pop('time_marginalization')
+ self.result.meta_data["likelihood"].pop("time_marginalization")
with self.assertRaises(AttributeError):
self.result.time_marginalization
def test_distance_marginalization(self):
self.assertEqual(
self.result.distance_marginalization,
- self.meta_data['likelihood']['distance_marginalization'])
+ self.meta_data["likelihood"]["distance_marginalization"],
+ )
def test_distance_marginalization_unset(self):
- self.result.meta_data['likelihood'].pop('distance_marginalization')
+ self.result.meta_data["likelihood"].pop("distance_marginalization")
with self.assertRaises(AttributeError):
self.result.distance_marginalization
def test_reference_frequency(self):
self.assertEqual(
self.result.reference_frequency,
- self.meta_data['likelihood']['waveform_arguments']['reference_frequency'])
+ self.meta_data["likelihood"]["waveform_arguments"]["reference_frequency"],
+ )
def test_reference_frequency_unset(self):
- self.result.meta_data['likelihood']['waveform_arguments'].pop('reference_frequency')
+ self.result.meta_data["likelihood"]["waveform_arguments"].pop(
+ "reference_frequency"
+ )
with self.assertRaises(AttributeError):
self.result.reference_frequency
def test_sampling_frequency(self):
self.assertEqual(
self.result.sampling_frequency,
- self.meta_data['likelihood']['sampling_frequency'])
+ self.meta_data["likelihood"]["sampling_frequency"],
+ )
def test_sampling_frequency_unset(self):
- self.result.meta_data['likelihood'].pop('sampling_frequency')
+ self.result.meta_data["likelihood"].pop("sampling_frequency")
with self.assertRaises(AttributeError):
self.result.sampling_frequency
def test_duration(self):
- self.assertEqual(
- self.result.duration,
- self.meta_data['likelihood']['duration'])
+ self.assertEqual(self.result.duration, self.meta_data["likelihood"]["duration"])
def test_duration_unset(self):
- self.result.meta_data['likelihood'].pop('duration')
+ self.result.meta_data["likelihood"].pop("duration")
with self.assertRaises(AttributeError):
self.result.duration
def test_start_time(self):
self.assertEqual(
- self.result.start_time,
- self.meta_data['likelihood']['start_time'])
+ self.result.start_time, self.meta_data["likelihood"]["start_time"]
+ )
def test_start_time_unset(self):
- self.result.meta_data['likelihood'].pop('start_time')
+ self.result.meta_data["likelihood"].pop("start_time")
with self.assertRaises(AttributeError):
self.result.start_time
def test_waveform_approximant(self):
self.assertEqual(
self.result.waveform_approximant,
- self.meta_data['likelihood']['waveform_arguments']['waveform_approximant'])
+ self.meta_data["likelihood"]["waveform_arguments"]["waveform_approximant"],
+ )
def test_waveform_approximant_unset(self):
- self.result.meta_data['likelihood']['waveform_arguments'].pop('waveform_approximant')
+ self.result.meta_data["likelihood"]["waveform_arguments"].pop(
+ "waveform_approximant"
+ )
with self.assertRaises(AttributeError):
self.result.waveform_approximant
def test_waveform_arguments(self):
self.assertEqual(
self.result.waveform_arguments,
- self.meta_data['likelihood']['waveform_arguments'])
+ self.meta_data["likelihood"]["waveform_arguments"],
+ )
def test_frequency_domain_source_model(self):
self.assertEqual(
self.result.frequency_domain_source_model,
- self.meta_data['likelihood']['frequency_domain_source_model'])
+ self.meta_data["likelihood"]["frequency_domain_source_model"],
+ )
def test_frequency_domain_source_model_unset(self):
- self.result.meta_data['likelihood'].pop('frequency_domain_source_model')
+ self.result.meta_data["likelihood"].pop("frequency_domain_source_model")
with self.assertRaises(AttributeError):
self.result.frequency_domain_source_model
def test_parameter_conversion(self):
self.assertEqual(
self.result.parameter_conversion,
- self.meta_data['likelihood']['parameter_conversion'])
+ self.meta_data["likelihood"]["parameter_conversion"],
+ )
def test_parameter_conversion_unset(self):
- self.result.meta_data['likelihood'].pop('parameter_conversion')
+ self.result.meta_data["likelihood"].pop("parameter_conversion")
with self.assertRaises(AttributeError):
self.result.parameter_conversion
def test_waveform_generator_class(self):
self.assertEqual(
self.result.waveform_generator_class,
- self.meta_data['likelihood']['waveform_generator_class'])
+ self.meta_data["likelihood"]["waveform_generator_class"],
+ )
def test_waveform_generator_class_unset(self):
- self.result.meta_data['likelihood'].pop('waveform_generator_class')
+ self.result.meta_data["likelihood"].pop("waveform_generator_class")
with self.assertRaises(AttributeError):
self.result.waveform_generator_class
def test_interferometer_names(self):
self.assertEqual(
self.result.interferometers,
- [name for name in self.meta_data['likelihood']['interferometers']])
+ [name for name in self.meta_data["likelihood"]["interferometers"]],
+ )
def test_detector_injection_properties(self):
self.assertEqual(
- self.result.detector_injection_properties('H1'),
- self.meta_data['likelihood']['interferometers']['H1'])
+ self.result.detector_injection_properties("H1"),
+ self.meta_data["likelihood"]["interferometers"]["H1"],
+ )
def test_detector_injection_properties_no_injection(self):
self.assertEqual(
- self.result.detector_injection_properties('not_a_detector'),
- None)
+ self.result.detector_injection_properties("not_a_detector"), None
+ )
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/gw_source_test.py b/test/gw_source_test.py
index 697616fa9c5758e8611c441d1a402c60e463af3d..93af82450c2e21c5dacba696e0ef9dcb5f1fd0de 100644
--- a/test/gw_source_test.py
+++ b/test/gw_source_test.py
@@ -8,19 +8,30 @@ import bilby
class TestLalBBH(unittest.TestCase):
-
def setUp(self):
self.parameters = dict(
- mass_1=30.0, mass_2=30.0, luminosity_distance=400.0, a_1=0.4,
- tilt_1=0.2, phi_12=1.0, a_2=0.8, tilt_2=2.7, phi_jl=2.9,
- theta_jn=0.3, phase=0.0)
+ mass_1=30.0,
+ mass_2=30.0,
+ luminosity_distance=400.0,
+ a_1=0.4,
+ tilt_1=0.2,
+ phi_12=1.0,
+ a_2=0.8,
+ tilt_2=2.7,
+ phi_jl=2.9,
+ theta_jn=0.3,
+ phase=0.0,
+ )
self.waveform_kwargs = dict(
- waveform_approximant='IMRPhenomPv2', reference_frequency=50.0,
- minimum_frequency=20.0, catch_waveform_errors=True)
+ waveform_approximant="IMRPhenomPv2",
+ reference_frequency=50.0,
+ minimum_frequency=20.0,
+ catch_waveform_errors=True,
+ )
self.frequency_array = bilby.core.utils.create_frequency_series(2048, 4)
self.bad_parameters = copy(self.parameters)
- self.bad_parameters['mass_1'] = -30.
-
+ self.bad_parameters["mass_1"] = -30.0
+
def tearDown(self):
del self.parameters
del self.waveform_kwargs
@@ -31,25 +42,35 @@ class TestLalBBH(unittest.TestCase):
self.parameters.update(self.waveform_kwargs)
self.assertIsInstance(
bilby.gw.source.lal_binary_black_hole(
- self.frequency_array, **self.parameters), dict)
+ self.frequency_array, **self.parameters
+ ),
+ dict,
+ )
def test_waveform_error_catching(self):
self.bad_parameters.update(self.waveform_kwargs)
- self.assertIsNone(bilby.gw.source.lal_binary_black_hole(
- self.frequency_array, **self.bad_parameters))
+ self.assertIsNone(
+ bilby.gw.source.lal_binary_black_hole(
+ self.frequency_array, **self.bad_parameters
+ )
+ )
def test_waveform_error_raising(self):
raise_error_parameters = copy(self.bad_parameters)
raise_error_parameters.update(self.waveform_kwargs)
- raise_error_parameters['catch_waveform_errors']=False
+ raise_error_parameters["catch_waveform_errors"] = False
with self.assertRaises(Exception):
bilby.gw.source.lal_binary_black_hole(
- self.frequency_array, **raise_error_parameters)
+ self.frequency_array, **raise_error_parameters
+ )
def test_lal_bbh_works_without_waveform_parameters(self):
self.assertIsInstance(
bilby.gw.source.lal_binary_black_hole(
- self.frequency_array, **self.parameters), dict)
+ self.frequency_array, **self.parameters
+ ),
+ dict,
+ )
# Removed due to issue with SimInspiralFD - see https://git.ligo.org/lscsoft/lalsuite/issues/153
# def test_lal_bbh_works_with_time_domain_approximant(self):
@@ -61,15 +82,27 @@ class TestLalBBH(unittest.TestCase):
class TestLalBNS(unittest.TestCase):
-
def setUp(self):
self.parameters = dict(
- mass_1=1.4, mass_2=1.4, luminosity_distance=400.0, a_1=0.4,
- a_2=0.3, tilt_1=0.2, tilt_2=1.7, phi_jl=0.2, phi_12=0.9,
- theta_jn=1.7, phase=0.0, lambda_1=100.0, lambda_2=100.0)
+ mass_1=1.4,
+ mass_2=1.4,
+ luminosity_distance=400.0,
+ a_1=0.4,
+ a_2=0.3,
+ tilt_1=0.2,
+ tilt_2=1.7,
+ phi_jl=0.2,
+ phi_12=0.9,
+ theta_jn=1.7,
+ phase=0.0,
+ lambda_1=100.0,
+ lambda_2=100.0,
+ )
self.waveform_kwargs = dict(
- waveform_approximant='IMRPhenomPv2_NRTidal',
- reference_frequency=50.0, minimum_frequency=20.0)
+ waveform_approximant="IMRPhenomPv2_NRTidal",
+ reference_frequency=50.0,
+ minimum_frequency=20.0,
+ )
self.frequency_array = bilby.core.utils.create_frequency_series(2048, 4)
def tearDown(self):
@@ -81,31 +114,44 @@ class TestLalBNS(unittest.TestCase):
self.parameters.update(self.waveform_kwargs)
self.assertIsInstance(
bilby.gw.source.lal_binary_neutron_star(
- self.frequency_array, **self.parameters), dict)
+ self.frequency_array, **self.parameters
+ ),
+ dict,
+ )
def test_lal_bns_works_without_waveform_parameters(self):
self.assertIsInstance(
bilby.gw.source.lal_binary_neutron_star(
- self.frequency_array, **self.parameters), dict)
+ self.frequency_array, **self.parameters
+ ),
+ dict,
+ )
def test_fails_without_tidal_parameters(self):
- self.parameters.pop('lambda_1')
- self.parameters.pop('lambda_2')
+ self.parameters.pop("lambda_1")
+ self.parameters.pop("lambda_2")
self.parameters.update(self.waveform_kwargs)
with self.assertRaises(TypeError):
bilby.gw.source.lal_binary_neutron_star(
- self.frequency_array, **self.parameters)
+ self.frequency_array, **self.parameters
+ )
class TestEccentricLalBBH(unittest.TestCase):
-
def setUp(self):
self.parameters = dict(
- mass_1=30.0, mass_2=30.0, luminosity_distance=400.0, theta_jn=0.0,
- phase=0.0, eccentricity=0.1)
+ mass_1=30.0,
+ mass_2=30.0,
+ luminosity_distance=400.0,
+ theta_jn=0.0,
+ phase=0.0,
+ eccentricity=0.1,
+ )
self.waveform_kwargs = dict(
- waveform_approximant='EccentricFD', reference_frequency=10.0,
- minimum_frequency=10.0)
+ waveform_approximant="EccentricFD",
+ reference_frequency=10.0,
+ minimum_frequency=10.0,
+ )
self.frequency_array = bilby.core.utils.create_frequency_series(2048, 4)
def tearDown(self):
@@ -117,25 +163,31 @@ class TestEccentricLalBBH(unittest.TestCase):
self.parameters.update(self.waveform_kwargs)
self.assertIsInstance(
bilby.gw.source.lal_eccentric_binary_black_hole_no_spins(
- self.frequency_array, **self.parameters), dict)
+ self.frequency_array, **self.parameters
+ ),
+ dict,
+ )
def test_lal_ebbh_works_without_waveform_parameters(self):
self.assertIsInstance(
bilby.gw.source.lal_eccentric_binary_black_hole_no_spins(
- self.frequency_array, **self.parameters), dict)
+ self.frequency_array, **self.parameters
+ ),
+ dict,
+ )
def test_fails_without_eccentricity(self):
- self.parameters.pop('eccentricity')
+ self.parameters.pop("eccentricity")
self.parameters.update(self.waveform_kwargs)
with self.assertRaises(TypeError):
bilby.gw.source.lal_eccentric_binary_black_hole_no_spins(
- self.frequency_array, **self.parameters)
+ self.frequency_array, **self.parameters
+ )
class TestROQBBH(unittest.TestCase):
-
def setUp(self):
- roq_dir = '/roq_basis'
+ roq_dir = "/roq_basis"
fnodes_linear_file = "{}/fnodes_linear.npy".format(roq_dir)
fnodes_linear = np.load(fnodes_linear_file).T
@@ -143,14 +195,25 @@ class TestROQBBH(unittest.TestCase):
fnodes_quadratic = np.load(fnodes_quadratic_file).T
self.parameters = dict(
- mass_1=30.0, mass_2=30.0, luminosity_distance=400.0, a_1=0.0,
- tilt_1=0.0, phi_12=0.0, a_2=0.0, tilt_2=0.0, phi_jl=0.0,
- theta_jn=0.0, phase=0.0)
+ mass_1=30.0,
+ mass_2=30.0,
+ luminosity_distance=400.0,
+ a_1=0.0,
+ tilt_1=0.0,
+ phi_12=0.0,
+ a_2=0.0,
+ tilt_2=0.0,
+ phi_jl=0.0,
+ theta_jn=0.0,
+ phase=0.0,
+ )
self.waveform_kwargs = dict(
frequency_nodes_linear=fnodes_linear,
frequency_nodes_quadratic=fnodes_quadratic,
- reference_frequency=50., minimum_frequency=20.,
- approximant='IMRPhenomPv2')
+ reference_frequency=50.0,
+ minimum_frequency=20.0,
+ approximant="IMRPhenomPv2",
+ )
self.frequency_array = bilby.core.utils.create_frequency_series(2048, 4)
def tearDown(self):
@@ -161,15 +224,16 @@ class TestROQBBH(unittest.TestCase):
def test_roq_runs_valid_parameters(self):
self.parameters.update(self.waveform_kwargs)
self.assertIsInstance(
- bilby.gw.source.roq(self.frequency_array, **self.parameters), dict)
+ bilby.gw.source.roq(self.frequency_array, **self.parameters), dict
+ )
def test_roq_fails_without_frequency_nodes(self):
self.parameters.update(self.waveform_kwargs)
- del self.parameters['frequency_nodes_linear']
- del self.parameters['frequency_nodes_quadratic']
+ del self.parameters["frequency_nodes_linear"]
+ del self.parameters["frequency_nodes_quadratic"]
with self.assertRaises(KeyError):
bilby.gw.source.roq(self.frequency_array, **self.parameters)
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/gw_utils_test.py b/test/gw_utils_test.py
index e9b7b6262c156dde1928c408f7d651810dd16462..c44a65cd2c6328336353df24f2e767c5cbe59bfb 100644
--- a/test/gw_utils_test.py
+++ b/test/gw_utils_test.py
@@ -14,9 +14,8 @@ from bilby.gw import utils as gwutils
class TestGWUtils(unittest.TestCase):
-
def setUp(self):
- self.outdir = 'outdir'
+ self.outdir = "outdir"
bilby.core.utils.check_directory_exists_and_if_not_mkdir(self.outdir)
def tearDown(self):
@@ -35,7 +34,7 @@ class TestGWUtils(unittest.TestCase):
freq_data = np.array([1, 2, 3])
df = 0.1
psd = gwutils.psd_from_freq_series(freq_data, df)
- self.assertTrue(np.all(psd == (freq_data * 2 * df ** 0.5)**2))
+ self.assertTrue(np.all(psd == (freq_data * 2 * df ** 0.5) ** 2))
def test_time_delay_from_geocenter(self):
"""
@@ -47,22 +46,23 @@ class TestGWUtils(unittest.TestCase):
ra = 0.5
dec = 0.2
time = 10
- self.assertEqual(
- gwutils.time_delay_geocentric(det1, det1, ra, dec, time), 0)
+ self.assertEqual(gwutils.time_delay_geocentric(det1, det1, ra, dec, time), 0)
self.assertAlmostEqual(
gwutils.time_delay_geocentric(det1, det2, ra, dec, time),
- 1.3253791114055397e-10, 14)
+ 1.3253791114055397e-10,
+ 14,
+ )
def test_get_polarization_tensor(self):
ra = 1
dec = 2.0
time = 10
psi = 0.1
- for mode in ['plus', 'cross', 'breathing', 'longitudinal', 'x', 'y']:
+ for mode in ["plus", "cross", "breathing", "longitudinal", "x", "y"]:
p = gwutils.get_polarization_tensor(ra, dec, time, psi, mode)
self.assertEqual(p.shape, (3, 3))
with self.assertRaises(ValueError):
- gwutils.get_polarization_tensor(ra, dec, time, psi, 'not-a-mode')
+ gwutils.get_polarization_tensor(ra, dec, time, psi, "not-a-mode")
def test_inner_product(self):
aa = np.array([1, 2, 3])
@@ -84,7 +84,8 @@ class TestGWUtils(unittest.TestCase):
self.assertEqual(
gwutils.optimal_snr_squared(aa, psd, duration),
- gwutils.noise_weighted_inner_product(aa, aa, psd, duration))
+ gwutils.noise_weighted_inner_product(aa, aa, psd, duration),
+ )
def test_matched_filter_snr(self):
signal = np.array([1e-23, 2e-23, 3e-23])
@@ -95,72 +96,86 @@ class TestGWUtils(unittest.TestCase):
duration = 4
mfsnr = gwutils.matched_filter_snr(
- signal, frequency_domain_strain, psd, duration)
+ signal, frequency_domain_strain, psd, duration
+ )
self.assertEqual(mfsnr, 25.510869054168282)
def test_get_event_time(self):
- events = ['GW150914', 'GW151012', 'GW151226', 'GW170104', 'GW170608',
- 'GW170729', 'GW170809', 'GW170814', 'GW170817', 'GW170818',
- 'GW170823']
+ events = [
+ "GW150914",
+ "GW151012",
+ "GW151226",
+ "GW170104",
+ "GW170608",
+ "GW170729",
+ "GW170809",
+ "GW170814",
+ "GW170817",
+ "GW170818",
+ "GW170823",
+ ]
for event in events:
self.assertTrue(isinstance(gwutils.get_event_time(event), float))
- self.assertTrue(gwutils.get_event_time('GW010290') is None)
+ self.assertTrue(gwutils.get_event_time("GW010290") is None)
def test_read_frame_file(self):
start_time = 0
end_time = 10
- channel = 'H1:GDS-CALIB_STRAIN'
+ channel = "H1:GDS-CALIB_STRAIN"
N = 100
times = np.linspace(start_time, end_time, N)
data = np.random.normal(0, 1, N)
ts = gwpy.timeseries.TimeSeries(data=data, times=times, t0=0)
ts.channel = gwpy.detector.Channel(channel)
ts.name = channel
- filename = os.path.join(self.outdir, 'test.gwf')
- ts.write(filename, format='gwf')
+ filename = os.path.join(self.outdir, "test.gwf")
+ ts.write(filename, format="gwf")
# Check reading without time limits
strain = gwutils.read_frame_file(
- filename, start_time=None, end_time=None, channel=channel)
+ filename, start_time=None, end_time=None, channel=channel
+ )
self.assertEqual(strain.channel.name, channel)
- self.assertTrue(np.all(strain.value==data[:-1]))
+ self.assertTrue(np.all(strain.value == data[:-1]))
# Check reading with time limits
start_cut = 2
end_cut = 8
strain = gwutils.read_frame_file(
- filename, start_time=start_cut, end_time=end_cut, channel=channel)
+ filename, start_time=start_cut, end_time=end_cut, channel=channel
+ )
idxs = (times > start_cut) & (times < end_cut)
# Dropping the last element - for some reason gwpy drops the last element when reading in data
- self.assertTrue(np.all(strain.value==data[idxs][:-1]))
+ self.assertTrue(np.all(strain.value == data[idxs][:-1]))
# Check reading with unknown channels
- strain = gwutils.read_frame_file(
- filename, start_time=None, end_time=None)
- self.assertTrue(np.all(strain.value==data[:-1]))
+ strain = gwutils.read_frame_file(filename, start_time=None, end_time=None)
+ self.assertTrue(np.all(strain.value == data[:-1]))
# Check reading with incorrect channel
strain = gwutils.read_frame_file(
- filename, start_time=None, end_time=None, channel='WRONG')
- self.assertTrue(np.all(strain.value==data[:-1]))
+ filename, start_time=None, end_time=None, channel="WRONG"
+ )
+ self.assertTrue(np.all(strain.value == data[:-1]))
ts = gwpy.timeseries.TimeSeries(data=data, times=times, t0=0)
- ts.name = 'NOT-A-KNOWN-CHANNEL'
- ts.write(filename, format='gwf')
- strain = gwutils.read_frame_file(
- filename, start_time=None, end_time=None)
+ ts.name = "NOT-A-KNOWN-CHANNEL"
+ ts.write(filename, format="gwf")
+ strain = gwutils.read_frame_file(filename, start_time=None, end_time=None)
self.assertEqual(strain, None)
def test_convert_args_list_to_float(self):
self.assertEqual(
- gwutils.convert_args_list_to_float(1, '2', 3.0), [1.0, 2.0, 3.0])
+ gwutils.convert_args_list_to_float(1, "2", 3.0), [1.0, 2.0, 3.0]
+ )
with self.assertRaises(ValueError):
- gwutils.convert_args_list_to_float(1, '2', 'ten')
+ gwutils.convert_args_list_to_float(1, "2", "ten")
def test_lalsim_SimInspiralTransformPrecessingNewInitialConditions(self):
- a = gwutils.lalsim_SimInspiralTransformPrecessingNewInitialConditions(
- 0.1, 0, 0.6, 0.5, 0.6, 0.1, 0.8, 30.6, 23.2, 50, 0)
+ a = gwutils.lalsim_SimInspiralTransformPrecessingNewInitialConditions(
+ 0.1, 0, 0.6, 0.5, 0.6, 0.1, 0.8, 30.6, 23.2, 50, 0
+ )
self.assertTrue(len(a) == 7)
def test_get_approximant(self):
@@ -169,22 +184,79 @@ class TestGWUtils(unittest.TestCase):
def test_lalsim_SimInspiralChooseFDWaveform(self):
a = gwutils.lalsim_SimInspiralChooseFDWaveform(
- 35.2, 20.4, 0.1, 0.2, 0.2, 0.2, 0.2, 0.1, 1000, 2, 2.3,
- 45., 0.1, 10, 0.01, 10, 1000, 20, None, lalsim.IMRPhenomPv2)
+ 35.2,
+ 20.4,
+ 0.1,
+ 0.2,
+ 0.2,
+ 0.2,
+ 0.2,
+ 0.1,
+ 1000,
+ 2,
+ 2.3,
+ 45.0,
+ 0.1,
+ 10,
+ 0.01,
+ 10,
+ 1000,
+ 20,
+ None,
+ lalsim.IMRPhenomPv2,
+ )
self.assertEqual(len(a), 2)
self.assertEqual(type(a[0]), lal.COMPLEX16FrequencySeries)
self.assertEqual(type(a[1]), lal.COMPLEX16FrequencySeries)
with self.assertRaises(RuntimeError):
_ = gwutils.lalsim_SimInspiralChooseFDWaveform(
- 35.2, 20.4, 0.1, 0.2, 0.2, 0.2, 0.2, 0.1, 1000, 2, 2.3,
- 45., 0.1, 10, 0.01, 10, 1000, 20, None, 'Fail')
+ 35.2,
+ 20.4,
+ 0.1,
+ 0.2,
+ 0.2,
+ 0.2,
+ 0.2,
+ 0.1,
+ 1000,
+ 2,
+ 2.3,
+ 45.0,
+ 0.1,
+ 10,
+ 0.01,
+ 10,
+ 1000,
+ 20,
+ None,
+ "Fail",
+ )
with self.assertRaises(ValueError):
_ = gwutils.lalsim_SimInspiralChooseFDWaveform(
- 35.2, 20.4, 0.1, 0.2, 0.2, 0.2, 0.2, 0.1, 1000, 2, 2.3,
- 45., 0.1, 10, 0.01, 10, 1000, 20, None, 1.5)
-
-
-if __name__ == '__main__':
+ 35.2,
+ 20.4,
+ 0.1,
+ 0.2,
+ 0.2,
+ 0.2,
+ 0.2,
+ 0.1,
+ 1000,
+ 2,
+ 2.3,
+ 45.0,
+ 0.1,
+ 10,
+ 0.01,
+ 10,
+ 1000,
+ 20,
+ None,
+ 1.5,
+ )
+
+
+if __name__ == "__main__":
unittest.main()
diff --git a/test/hyper_pe_test.py b/test/hyper_pe_test.py
index e7872df9bb939fe3b92688f661241d0c62ec1cb0..12773802008d4d64dafed5fc647953472574d50b 100644
--- a/test/hyper_pe_test.py
+++ b/test/hyper_pe_test.py
@@ -5,15 +5,14 @@ import bilby.hyper as hyp
class TestHyperLikelihood(unittest.TestCase):
-
def setUp(self):
- self.keys = ['a', 'b', 'c']
+ self.keys = ["a", "b", "c"]
self.lengths = [300, 400, 500]
self.posteriors = list()
for ii, length in enumerate(self.lengths):
self.posteriors.append(
- pd.DataFrame(
- {key: np.random.normal(0, 1, length) for key in self.keys}))
+ pd.DataFrame({key: np.random.normal(0, 1, length) for key in self.keys})
+ )
self.log_evidences = [2, 2, 2]
self.model = hyp.model.Model(list())
self.sampling_model = hyp.model.Model(list())
@@ -26,42 +25,58 @@ class TestHyperLikelihood(unittest.TestCase):
def test_evidence_factor_with_evidences(self):
like = hyp.likelihood.HyperparameterLikelihood(
- self.posteriors, self.model, self.sampling_model,
- log_evidences=self.log_evidences)
+ self.posteriors,
+ self.model,
+ self.sampling_model,
+ log_evidences=self.log_evidences,
+ )
self.assertEqual(like.evidence_factor, 6)
def test_evidence_factor_without_evidences(self):
like = hyp.likelihood.HyperparameterLikelihood(
- self.posteriors, self.model, self.sampling_model)
+ self.posteriors, self.model, self.sampling_model
+ )
self.assertTrue(np.isnan(like.evidence_factor))
def test_len_samples_with_max_samples(self):
like = hyp.likelihood.HyperparameterLikelihood(
- self.posteriors, self.model, self.sampling_model,
- log_evidences=self.log_evidences, max_samples=10)
+ self.posteriors,
+ self.model,
+ self.sampling_model,
+ log_evidences=self.log_evidences,
+ max_samples=10,
+ )
self.assertEqual(like.samples_per_posterior, 10)
def test_len_samples_without_max_samples(self):
like = hyp.likelihood.HyperparameterLikelihood(
- self.posteriors, self.model, self.sampling_model,
- log_evidences=self.log_evidences)
+ self.posteriors,
+ self.model,
+ self.sampling_model,
+ log_evidences=self.log_evidences,
+ )
self.assertEqual(like.samples_per_posterior, min(self.lengths))
def test_resample_with_max_samples(self):
like = hyp.likelihood.HyperparameterLikelihood(
- self.posteriors, self.model, self.sampling_model,
- log_evidences=self.log_evidences)
+ self.posteriors,
+ self.model,
+ self.sampling_model,
+ log_evidences=self.log_evidences,
+ )
resampled = like.resample_posteriors()
- self.assertEqual(resampled['a'].shape,
- (len(self.lengths), min(self.lengths)))
+ self.assertEqual(resampled["a"].shape, (len(self.lengths), min(self.lengths)))
def test_resample_without_max_samples(self):
like = hyp.likelihood.HyperparameterLikelihood(
- self.posteriors, self.model, self.sampling_model,
- log_evidences=self.log_evidences)
+ self.posteriors,
+ self.model,
+ self.sampling_model,
+ log_evidences=self.log_evidences,
+ )
resampled = like.resample_posteriors(10)
- self.assertEqual(resampled['a'].shape, (len(self.lengths), 10))
+ self.assertEqual(resampled["a"].shape, (len(self.lengths), 10))
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/likelihood_test.py b/test/likelihood_test.py
index 3bc3d0b97b541af86b7d3dd10bc8e2941a82801d..49cb5db2184b3e37ac13f54f1c46e2be39a3a7a8 100644
--- a/test/likelihood_test.py
+++ b/test/likelihood_test.py
@@ -1,18 +1,24 @@
from __future__ import absolute_import
+
# import bilby
import unittest
from mock import MagicMock
import mock
import numpy as np
from bilby.core.likelihood import (
- Likelihood, GaussianLikelihood, PoissonLikelihood, StudentTLikelihood,
- Analytical1DLikelihood, ExponentialLikelihood,
+ Likelihood,
+ GaussianLikelihood,
+ PoissonLikelihood,
+ StudentTLikelihood,
+ Analytical1DLikelihood,
+ ExponentialLikelihood,
AnalyticalMultidimensionalCovariantGaussian,
- AnalyticalMultidimensionalBimodalCovariantGaussian, JointLikelihood)
+ AnalyticalMultidimensionalBimodalCovariantGaussian,
+ JointLikelihood,
+)
class TestLikelihoodBase(unittest.TestCase):
-
def setUp(self):
self.likelihood = Likelihood()
@@ -20,8 +26,8 @@ class TestLikelihoodBase(unittest.TestCase):
del self.likelihood
def test_repr(self):
- self.likelihood = Likelihood(parameters=['a', 'b'])
- expected = 'Likelihood(parameters=[\'a\', \'b\'])'
+ self.likelihood = Likelihood(parameters=["a", "b"])
+ expected = "Likelihood(parameters=['a', 'b'])"
self.assertEqual(expected, repr(self.likelihood))
def test_base_log_likelihood(self):
@@ -47,7 +53,6 @@ class TestLikelihoodBase(unittest.TestCase):
class TestAnalytical1DLikelihood(unittest.TestCase):
-
def setUp(self):
self.x = np.arange(start=0, stop=100, step=1)
self.y = np.arange(start=0, stop=100, step=1)
@@ -58,9 +63,11 @@ class TestAnalytical1DLikelihood(unittest.TestCase):
self.func = test_func
self.parameter1_value = 4
self.parameter2_value = 7
- self.analytical_1d_likelihood = Analytical1DLikelihood(x=self.x, y=self.y, func=self.func)
- self.analytical_1d_likelihood.parameters['parameter1'] = self.parameter1_value
- self.analytical_1d_likelihood.parameters['parameter2'] = self.parameter2_value
+ self.analytical_1d_likelihood = Analytical1DLikelihood(
+ x=self.x, y=self.y, func=self.func
+ )
+ self.analytical_1d_likelihood.parameters["parameter1"] = self.parameter1_value
+ self.analytical_1d_likelihood.parameters["parameter2"] = self.parameter2_value
def tearDown(self):
del self.x
@@ -122,9 +129,12 @@ class TestAnalytical1DLikelihood(unittest.TestCase):
self.analytical_1d_likelihood.func = new_func
def test_parameters(self):
- expected_parameters = dict(parameter1=self.parameter1_value,
- parameter2=self.parameter2_value)
- self.assertDictEqual(expected_parameters, self.analytical_1d_likelihood.parameters)
+ expected_parameters = dict(
+ parameter1=self.parameter1_value, parameter2=self.parameter2_value
+ )
+ self.assertDictEqual(
+ expected_parameters, self.analytical_1d_likelihood.parameters
+ )
def test_n(self):
self.assertEqual(len(self.x), self.analytical_1d_likelihood.n)
@@ -137,18 +147,22 @@ class TestAnalytical1DLikelihood(unittest.TestCase):
def test_model_parameters(self):
sigma = 5
self.analytical_1d_likelihood.sigma = sigma
- self.analytical_1d_likelihood.parameters['sigma'] = sigma
- expected_model_parameters = dict(parameter1=self.parameter1_value,
- parameter2=self.parameter2_value)
- self.assertDictEqual(expected_model_parameters, self.analytical_1d_likelihood.model_parameters)
+ self.analytical_1d_likelihood.parameters["sigma"] = sigma
+ expected_model_parameters = dict(
+ parameter1=self.parameter1_value, parameter2=self.parameter2_value
+ )
+ self.assertDictEqual(
+ expected_model_parameters, self.analytical_1d_likelihood.model_parameters
+ )
def test_repr(self):
- expected = 'Analytical1DLikelihood(x={}, y={}, func={})'.format(self.x, self.y, self.func.__name__)
+ expected = "Analytical1DLikelihood(x={}, y={}, func={})".format(
+ self.x, self.y, self.func.__name__
+ )
self.assertEqual(expected, repr(self.analytical_1d_likelihood))
class TestGaussianLikelihood(unittest.TestCase):
-
def setUp(self):
self.N = 100
self.sigma = 0.1
@@ -168,57 +182,51 @@ class TestGaussianLikelihood(unittest.TestCase):
del self.function
def test_known_sigma(self):
- likelihood = GaussianLikelihood(
- self.x, self.y, self.function, self.sigma)
- likelihood.parameters['m'] = 2
- likelihood.parameters['c'] = 0
+ likelihood = GaussianLikelihood(self.x, self.y, self.function, self.sigma)
+ likelihood.parameters["m"] = 2
+ likelihood.parameters["c"] = 0
likelihood.log_likelihood()
self.assertEqual(likelihood.sigma, self.sigma)
def test_known_array_sigma(self):
sigma_array = np.ones(self.N) * self.sigma
- likelihood = GaussianLikelihood(
- self.x, self.y, self.function, sigma_array)
- likelihood.parameters['m'] = 2
- likelihood.parameters['c'] = 0
+ likelihood = GaussianLikelihood(self.x, self.y, self.function, sigma_array)
+ likelihood.parameters["m"] = 2
+ likelihood.parameters["c"] = 0
likelihood.log_likelihood()
self.assertTrue(type(likelihood.sigma) == type(sigma_array))
self.assertTrue(all(likelihood.sigma == sigma_array))
def test_set_sigma_None(self):
- likelihood = GaussianLikelihood(
- self.x, self.y, self.function, sigma=None)
- likelihood.parameters['m'] = 2
- likelihood.parameters['c'] = 0
+ likelihood = GaussianLikelihood(self.x, self.y, self.function, sigma=None)
+ likelihood.parameters["m"] = 2
+ likelihood.parameters["c"] = 0
self.assertTrue(likelihood.sigma is None)
with self.assertRaises(TypeError):
likelihood.log_likelihood()
def test_sigma_float(self):
- likelihood = GaussianLikelihood(
- self.x, self.y, self.function, sigma=None)
- likelihood.parameters['m'] = 2
- likelihood.parameters['c'] = 0
- likelihood.parameters['sigma'] = 1
+ likelihood = GaussianLikelihood(self.x, self.y, self.function, sigma=None)
+ likelihood.parameters["m"] = 2
+ likelihood.parameters["c"] = 0
+ likelihood.parameters["sigma"] = 1
likelihood.log_likelihood()
self.assertTrue(likelihood.sigma == 1)
def test_sigma_other(self):
- likelihood = GaussianLikelihood(
- self.x, self.y, self.function, sigma=None)
+ likelihood = GaussianLikelihood(self.x, self.y, self.function, sigma=None)
with self.assertRaises(ValueError):
- likelihood.sigma = 'test'
+ likelihood.sigma = "test"
def test_repr(self):
- likelihood = GaussianLikelihood(
- self.x, self.y, self.function, sigma=self.sigma)
- expected = 'GaussianLikelihood(x={}, y={}, func={}, sigma={})' \
- .format(self.x, self.y, self.function.__name__, self.sigma)
+ likelihood = GaussianLikelihood(self.x, self.y, self.function, sigma=self.sigma)
+ expected = "GaussianLikelihood(x={}, y={}, func={}, sigma={})".format(
+ self.x, self.y, self.function.__name__, self.sigma
+ )
self.assertEqual(expected, repr(likelihood))
class TestStudentTLikelihood(unittest.TestCase):
-
def setUp(self):
self.N = 100
self.nu = self.N - 2
@@ -240,55 +248,50 @@ class TestStudentTLikelihood(unittest.TestCase):
def test_known_sigma(self):
likelihood = StudentTLikelihood(
- self.x, self.y, self.function, self.nu, self.sigma)
- likelihood.parameters['m'] = 2
- likelihood.parameters['c'] = 0
+ self.x, self.y, self.function, self.nu, self.sigma
+ )
+ likelihood.parameters["m"] = 2
+ likelihood.parameters["c"] = 0
likelihood.log_likelihood()
self.assertEqual(likelihood.sigma, self.sigma)
def test_set_nu_none(self):
- likelihood = StudentTLikelihood(
- self.x, self.y, self.function, nu=None)
- likelihood.parameters['m'] = 2
- likelihood.parameters['c'] = 0
+ likelihood = StudentTLikelihood(self.x, self.y, self.function, nu=None)
+ likelihood.parameters["m"] = 2
+ likelihood.parameters["c"] = 0
self.assertTrue(likelihood.nu is None)
def test_log_likelihood_nu_none(self):
- likelihood = StudentTLikelihood(
- self.x, self.y, self.function, nu=None)
- likelihood.parameters['m'] = 2
- likelihood.parameters['c'] = 0
+ likelihood = StudentTLikelihood(self.x, self.y, self.function, nu=None)
+ likelihood.parameters["m"] = 2
+ likelihood.parameters["c"] = 0
with self.assertRaises((ValueError, TypeError)):
# ValueError in Python2, TypeError in Python3
likelihood.log_likelihood()
def test_log_likelihood_nu_zero(self):
- likelihood = StudentTLikelihood(
- self.x, self.y, self.function, nu=0)
- likelihood.parameters['m'] = 2
- likelihood.parameters['c'] = 0
+ likelihood = StudentTLikelihood(self.x, self.y, self.function, nu=0)
+ likelihood.parameters["m"] = 2
+ likelihood.parameters["c"] = 0
with self.assertRaises(ValueError):
likelihood.log_likelihood()
def test_log_likelihood_nu_negative(self):
- likelihood = StudentTLikelihood(
- self.x, self.y, self.function, nu=-1)
- likelihood.parameters['m'] = 2
- likelihood.parameters['c'] = 0
+ likelihood = StudentTLikelihood(self.x, self.y, self.function, nu=-1)
+ likelihood.parameters["m"] = 2
+ likelihood.parameters["c"] = 0
with self.assertRaises(ValueError):
likelihood.log_likelihood()
def test_setting_nu_positive_does_not_change_class_attribute(self):
- likelihood = StudentTLikelihood(
- self.x, self.y, self.function, nu=None)
- likelihood.parameters['m'] = 2
- likelihood.parameters['c'] = 0
- likelihood.parameters['nu'] = 98
+ likelihood = StudentTLikelihood(self.x, self.y, self.function, nu=None)
+ likelihood.parameters["m"] = 2
+ likelihood.parameters["c"] = 0
+ likelihood.parameters["nu"] = 98
self.assertTrue(likelihood.nu == 98)
def test_lam(self):
- likelihood = StudentTLikelihood(
- self.x, self.y, self.function, nu=0, sigma=0.5)
+ likelihood = StudentTLikelihood(self.x, self.y, self.function, nu=0, sigma=0.5)
self.assertAlmostEqual(4.0, likelihood.lam)
@@ -296,20 +299,21 @@ class TestStudentTLikelihood(unittest.TestCase):
nu = 0
sigma = 0.5
likelihood = StudentTLikelihood(
- self.x, self.y, self.function, nu=nu, sigma=sigma)
- expected = 'StudentTLikelihood(x={}, y={}, func={}, nu={}, sigma={})' \
- .format(self.x, self.y, self.function.__name__, nu, sigma)
+ self.x, self.y, self.function, nu=nu, sigma=sigma
+ )
+ expected = "StudentTLikelihood(x={}, y={}, func={}, nu={}, sigma={})".format(
+ self.x, self.y, self.function.__name__, nu, sigma
+ )
self.assertEqual(expected, repr(likelihood))
class TestPoissonLikelihood(unittest.TestCase):
-
def setUp(self):
self.N = 100
self.mu = 5
self.x = np.linspace(0, 1, self.N)
self.y = np.random.poisson(self.mu, self.N)
- self.yfloat = np.copy(self.y) * 1.
+ self.yfloat = np.copy(self.y) * 1.0
self.yneg = np.copy(self.y)
self.yneg[0] = -1
@@ -343,13 +347,13 @@ class TestPoissonLikelihood(unittest.TestCase):
PoissonLikelihood(self.x, self.yneg, self.function)
def test_neg_rate(self):
- self.poisson_likelihood.parameters['c'] = -2
+ self.poisson_likelihood.parameters["c"] = -2
with self.assertRaises(ValueError):
self.poisson_likelihood.log_likelihood()
def test_neg_rate_array(self):
likelihood = PoissonLikelihood(self.x, self.y, self.function_array)
- likelihood.parameters['c'] = -2
+ likelihood.parameters["c"] = -2
with self.assertRaises(ValueError):
likelihood.log_likelihood()
@@ -376,43 +380,50 @@ class TestPoissonLikelihood(unittest.TestCase):
self.poisson_likelihood.y = 5.3
def test_log_likelihood_wrong_func_return_type(self):
- poisson_likelihood = PoissonLikelihood(x=self.x, y=self.y, func=lambda x: 'test')
+ poisson_likelihood = PoissonLikelihood(
+ x=self.x, y=self.y, func=lambda x: "test"
+ )
with self.assertRaises(ValueError):
poisson_likelihood.log_likelihood()
def test_log_likelihood_negative_func_return_element(self):
- poisson_likelihood = PoissonLikelihood(x=self.x, y=self.y, func=lambda x: np.array([3, 6, -2]))
+ poisson_likelihood = PoissonLikelihood(
+ x=self.x, y=self.y, func=lambda x: np.array([3, 6, -2])
+ )
with self.assertRaises(ValueError):
poisson_likelihood.log_likelihood()
def test_log_likelihood_zero_func_return_element(self):
- poisson_likelihood = PoissonLikelihood(x=self.x, y=self.y, func=lambda x: np.array([3, 6, 0]))
+ poisson_likelihood = PoissonLikelihood(
+ x=self.x, y=self.y, func=lambda x: np.array([3, 6, 0])
+ )
self.assertEqual(-np.inf, poisson_likelihood.log_likelihood())
def test_log_likelihood_dummy(self):
""" Merely tests if it goes into the right if else bracket """
poisson_likelihood = PoissonLikelihood(
- x=self.x, y=self.y, func=lambda x: np.linspace(1, 100, self.N))
- with mock.patch('numpy.sum') as m:
+ x=self.x, y=self.y, func=lambda x: np.linspace(1, 100, self.N)
+ )
+ with mock.patch("numpy.sum") as m:
m.return_value = 1
self.assertEqual(1, poisson_likelihood.log_likelihood())
def test_repr(self):
- likelihood = PoissonLikelihood(
- self.x, self.y, self.function)
- expected = 'PoissonLikelihood(x={}, y={}, func={})'.format(self.x, self.y, self.function.__name__)
+ likelihood = PoissonLikelihood(self.x, self.y, self.function)
+ expected = "PoissonLikelihood(x={}, y={}, func={})".format(
+ self.x, self.y, self.function.__name__
+ )
self.assertEqual(expected, repr(likelihood))
class TestExponentialLikelihood(unittest.TestCase):
-
def setUp(self):
self.N = 100
self.mu = 5
self.x = np.linspace(0, 1, self.N)
self.y = np.random.exponential(self.mu, self.N)
self.yneg = np.copy(self.y)
- self.yneg[0] = -1.
+ self.yneg[0] = -1.0
def test_function(x, c):
return c
@@ -423,7 +434,8 @@ class TestExponentialLikelihood(unittest.TestCase):
self.function = test_function
self.function_array = test_function_array
self.exponential_likelihood = ExponentialLikelihood(
- x=self.x, y=self.y, func=self.function)
+ x=self.x, y=self.y, func=self.function
+ )
def tearDown(self):
del self.N
@@ -440,12 +452,12 @@ class TestExponentialLikelihood(unittest.TestCase):
def test_negative_function(self):
likelihood = ExponentialLikelihood(self.x, self.y, self.function)
- likelihood.parameters['c'] = -1
+ likelihood.parameters["c"] = -1
self.assertEqual(likelihood.log_likelihood(), -np.inf)
def test_negative_array_function(self):
likelihood = ExponentialLikelihood(self.x, self.y, self.function_array)
- likelihood.parameters['c'] = -1
+ likelihood.parameters["c"] = -1
self.assertEqual(likelihood.log_likelihood(), -np.inf)
def test_init_y(self):
@@ -482,25 +494,27 @@ class TestExponentialLikelihood(unittest.TestCase):
def test_log_likelihood_default(self):
""" Merely tests that it ends up at the right place in the code """
exponential_likelihood = ExponentialLikelihood(
- x=self.x, y=self.y, func=lambda x: np.array([4.2]))
- with mock.patch('numpy.sum') as m:
+ x=self.x, y=self.y, func=lambda x: np.array([4.2])
+ )
+ with mock.patch("numpy.sum") as m:
m.return_value = 3
self.assertEqual(-3, exponential_likelihood.log_likelihood())
def test_repr(self):
- expected = 'ExponentialLikelihood(x={}, y={}, func={})'.format(self.x, self.y, self.function.__name__)
+ expected = "ExponentialLikelihood(x={}, y={}, func={})".format(
+ self.x, self.y, self.function.__name__
+ )
self.assertEqual(expected, repr(self.exponential_likelihood))
class TestAnalyticalMultidimensionalCovariantGaussian(unittest.TestCase):
-
def setUp(self):
self.cov = [[1, 0, 0], [0, 4, 0], [0, 0, 9]]
self.sigma = [1, 2, 3]
self.mean = [10, 11, 12]
self.likelihood = AnalyticalMultidimensionalCovariantGaussian(
- mean=self.mean,
- cov=self.cov)
+ mean=self.mean, cov=self.cov
+ )
def tearDown(self):
del self.cov
@@ -525,20 +539,18 @@ class TestAnalyticalMultidimensionalCovariantGaussian(unittest.TestCase):
def test_log_likelihood(self):
likelihood = AnalyticalMultidimensionalCovariantGaussian(mean=[0], cov=[1])
- self.assertEqual(-np.log(2*np.pi)/2, likelihood.log_likelihood())
+ self.assertEqual(-np.log(2 * np.pi) / 2, likelihood.log_likelihood())
class TestAnalyticalMultidimensionalBimodalCovariantGaussian(unittest.TestCase):
-
def setUp(self):
self.cov = [[1, 0, 0], [0, 4, 0], [0, 0, 9]]
self.sigma = [1, 2, 3]
self.mean_1 = [10, 11, 12]
self.mean_2 = [20, 21, 22]
self.likelihood = AnalyticalMultidimensionalBimodalCovariantGaussian(
- mean_1=self.mean_1,
- mean_2=self.mean_2,
- cov=self.cov)
+ mean_1=self.mean_1, mean_2=self.mean_2, cov=self.cov
+ )
def tearDown(self):
del self.cov
@@ -566,39 +578,44 @@ class TestAnalyticalMultidimensionalBimodalCovariantGaussian(unittest.TestCase):
self.assertEqual(3, self.likelihood.dim)
def test_log_likelihood(self):
- likelihood = AnalyticalMultidimensionalBimodalCovariantGaussian(mean_1=[0], mean_2=[0], cov=[1])
- self.assertEqual(-np.log(2*np.pi)/2, likelihood.log_likelihood())
+ likelihood = AnalyticalMultidimensionalBimodalCovariantGaussian(
+ mean_1=[0], mean_2=[0], cov=[1]
+ )
+ self.assertEqual(-np.log(2 * np.pi) / 2, likelihood.log_likelihood())
-class TestJointLikelihood(unittest.TestCase):
+class TestJointLikelihood(unittest.TestCase):
def setUp(self):
self.x = np.array([1, 2, 3])
self.y = np.array([1, 2, 3])
self.first_likelihood = GaussianLikelihood(
- x=self.x, y=self.y,
- func=lambda x, param1, param2: (param1 + param2) * x, sigma=1)
+ x=self.x,
+ y=self.y,
+ func=lambda x, param1, param2: (param1 + param2) * x,
+ sigma=1,
+ )
self.second_likelihood = PoissonLikelihood(
- x=self.x, y=self.y,
- func=lambda x, param2, param3: (param2 + param3) * x)
+ x=self.x, y=self.y, func=lambda x, param2, param3: (param2 + param3) * x
+ )
self.third_likelihood = ExponentialLikelihood(
- x=self.x, y=self.y,
- func=lambda x, param4, param5: (param4 + param5) * x)
+ x=self.x, y=self.y, func=lambda x, param4, param5: (param4 + param5) * x
+ )
self.joint_likelihood = JointLikelihood(
- self.first_likelihood, self.second_likelihood,
- self.third_likelihood)
-
- self.first_likelihood.parameters['param1'] = 1
- self.first_likelihood.parameters['param2'] = 2
- self.second_likelihood.parameters['param2'] = 2
- self.second_likelihood.parameters['param3'] = 3
- self.third_likelihood.parameters['param4'] = 4
- self.third_likelihood.parameters['param5'] = 5
-
- self.joint_likelihood.parameters['param1'] = 1
- self.joint_likelihood.parameters['param2'] = 2
- self.joint_likelihood.parameters['param3'] = 3
- self.joint_likelihood.parameters['param4'] = 4
- self.joint_likelihood.parameters['param5'] = 5
+ self.first_likelihood, self.second_likelihood, self.third_likelihood
+ )
+
+ self.first_likelihood.parameters["param1"] = 1
+ self.first_likelihood.parameters["param2"] = 2
+ self.second_likelihood.parameters["param2"] = 2
+ self.second_likelihood.parameters["param3"] = 3
+ self.third_likelihood.parameters["param4"] = 4
+ self.third_likelihood.parameters["param5"] = 5
+
+ self.joint_likelihood.parameters["param1"] = 1
+ self.joint_likelihood.parameters["param2"] = 2
+ self.joint_likelihood.parameters["param3"] = 3
+ self.joint_likelihood.parameters["param4"] = 4
+ self.joint_likelihood.parameters["param5"] = 5
def tearDown(self):
del self.x
@@ -609,55 +626,69 @@ class TestJointLikelihood(unittest.TestCase):
del self.joint_likelihood
def test_parameters_consistent_from_init(self):
- expected = dict(param1=1, param2=2, param3=3, param4=4, param5=5, )
+ expected = dict(param1=1, param2=2, param3=3, param4=4, param5=5,)
self.assertDictEqual(expected, self.joint_likelihood.parameters)
def test_log_likelihood_correctly_sums(self):
- expected = self.first_likelihood.log_likelihood() + \
- self.second_likelihood.log_likelihood() + \
- self.third_likelihood.log_likelihood()
+ expected = (
+ self.first_likelihood.log_likelihood()
+ + self.second_likelihood.log_likelihood()
+ + self.third_likelihood.log_likelihood()
+ )
self.assertEqual(expected, self.joint_likelihood.log_likelihood())
def test_log_likelihood_checks_parameter_updates(self):
- self.first_likelihood.parameters['param2'] = 7
- self.second_likelihood.parameters['param2'] = 7
- self.joint_likelihood.parameters['param2'] = 7
- expected = self.first_likelihood.log_likelihood() + \
- self.second_likelihood.log_likelihood() + \
- self.third_likelihood.log_likelihood()
+ self.first_likelihood.parameters["param2"] = 7
+ self.second_likelihood.parameters["param2"] = 7
+ self.joint_likelihood.parameters["param2"] = 7
+ expected = (
+ self.first_likelihood.log_likelihood()
+ + self.second_likelihood.log_likelihood()
+ + self.third_likelihood.log_likelihood()
+ )
self.assertEqual(expected, self.joint_likelihood.log_likelihood())
def test_list_element_parameters_are_updated(self):
- self.joint_likelihood.parameters['param2'] = 7
- self.assertEqual(self.joint_likelihood.parameters['param2'],
- self.joint_likelihood.likelihoods[0].parameters['param2'])
- self.assertEqual(self.joint_likelihood.parameters['param2'],
- self.joint_likelihood.likelihoods[1].parameters['param2'])
+ self.joint_likelihood.parameters["param2"] = 7
+ self.assertEqual(
+ self.joint_likelihood.parameters["param2"],
+ self.joint_likelihood.likelihoods[0].parameters["param2"],
+ )
+ self.assertEqual(
+ self.joint_likelihood.parameters["param2"],
+ self.joint_likelihood.likelihoods[1].parameters["param2"],
+ )
def test_log_noise_likelihood(self):
self.first_likelihood.noise_log_likelihood = MagicMock(return_value=1)
self.second_likelihood.noise_log_likelihood = MagicMock(return_value=2)
self.third_likelihood.noise_log_likelihood = MagicMock(return_value=3)
self.joint_likelihood = JointLikelihood(
- self.first_likelihood, self.second_likelihood,
- self.third_likelihood)
- expected = self.first_likelihood.noise_log_likelihood() + \
- self.second_likelihood.noise_log_likelihood() + \
- self.third_likelihood.noise_log_likelihood()
+ self.first_likelihood, self.second_likelihood, self.third_likelihood
+ )
+ expected = (
+ self.first_likelihood.noise_log_likelihood()
+ + self.second_likelihood.noise_log_likelihood()
+ + self.third_likelihood.noise_log_likelihood()
+ )
self.assertEqual(expected, self.joint_likelihood.noise_log_likelihood())
def test_init_with_list_of_likelihoods(self):
with self.assertRaises(ValueError):
- JointLikelihood([self.first_likelihood, self.second_likelihood,
- self.third_likelihood])
+ JointLikelihood(
+ [self.first_likelihood, self.second_likelihood, self.third_likelihood]
+ )
def test_setting_single_likelihood(self):
self.joint_likelihood.likelihoods = self.first_likelihood
- self.assertEqual(self.first_likelihood.log_likelihood(), self.joint_likelihood.log_likelihood())
+ self.assertEqual(
+ self.first_likelihood.log_likelihood(),
+ self.joint_likelihood.log_likelihood(),
+ )
def test_setting_likelihood_other(self):
with self.assertRaises(ValueError):
- self.joint_likelihood.likelihoods = 'test'
+ self.joint_likelihood.likelihoods = "test"
# Appending is not supported
# def test_appending(self):
@@ -666,5 +697,5 @@ class TestJointLikelihood(unittest.TestCase):
# self.assertDictEqual(self.joint_likelihood.parameters, joint_likelihood.parameters)
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/make_standard_data.py b/test/make_standard_data.py
index 458ce69b4652ba7cd90fd90a3c746d055cc0b60f..7b0496182b355badf9a9add14ad9616877cc9018 100644
--- a/test/make_standard_data.py
+++ b/test/make_standard_data.py
@@ -9,50 +9,59 @@ from bilby.gw.waveform_generator import WaveformGenerator
np.random.seed(10)
-time_duration = 4.
-sampling_frequency = 4096.
+time_duration = 4.0
+sampling_frequency = 4096.0
simulation_parameters = dict(
- mass_1=36.,
- mass_2=29.,
- a_1=0.,
- a_2=0.,
- tilt_1=0.,
- tilt_2=0.,
- phi_12=0.,
- phi_jl=0.,
- luminosity_distance=100.,
+ mass_1=36.0,
+ mass_2=29.0,
+ a_1=0.0,
+ a_2=0.0,
+ tilt_1=0.0,
+ tilt_2=0.0,
+ phi_12=0.0,
+ phi_jl=0.0,
+ luminosity_distance=100.0,
theta_jn=0.4,
phase=1.3,
- waveform_approximant='IMRPhenomPv2',
- reference_frequency=50.,
+ waveform_approximant="IMRPhenomPv2",
+ reference_frequency=50.0,
ra=1.375,
dec=-1.2108,
geocent_time=1126259642.413,
- psi=2.659
+ psi=2.659,
)
waveform_generator = WaveformGenerator(
- duration=time_duration, sampling_frequency=sampling_frequency,
+ duration=time_duration,
+ sampling_frequency=sampling_frequency,
frequency_domain_source_model=bilby.gw.source.lal_binary_black_hole,
- parameters=simulation_parameters)
+ parameters=simulation_parameters,
+)
signal = waveform_generator.frequency_domain_strain()
IFO = bilby.gw.detector.get_interferometer_with_fake_noise_and_injection(
- name='H1', injection_polarizations=signal,
- injection_parameters=simulation_parameters, duration=time_duration,
- plot=False, sampling_frequency=sampling_frequency)
+ name="H1",
+ injection_polarizations=signal,
+ injection_parameters=simulation_parameters,
+ duration=time_duration,
+ plot=False,
+ sampling_frequency=sampling_frequency,
+)
hf_signal_and_noise = IFO.strain_data.frequency_domain_strain
frequencies = bilby.core.utils.create_frequency_series(
- sampling_frequency=sampling_frequency, duration=time_duration)
+ sampling_frequency=sampling_frequency, duration=time_duration
+)
-if __name__ == '__main__':
+if __name__ == "__main__":
dir_path = os.path.dirname(os.path.realpath(__file__))
- with open(dir_path + '/standard_data.txt', 'w+') as f:
+ with open(dir_path + "/standard_data.txt", "w+") as f:
np.savetxt(
f,
- np.column_stack([frequencies,
- hf_signal_and_noise.view(float).reshape(-1, 2)]),
- header='frequency hf_real hf_imag')
+ np.column_stack(
+ [frequencies, hf_signal_and_noise.view(float).reshape(-1, 2)]
+ ),
+ header="frequency hf_real hf_imag",
+ )
diff --git a/test/noise_realisation_test.py b/test/noise_realisation_test.py
index 15aa404f4d00092fde0d093a3eba6260d961efeb..dbaae44a53fb5e6cb5a352c9f0ea24cddf3bf62d 100644
--- a/test/noise_realisation_test.py
+++ b/test/noise_realisation_test.py
@@ -6,44 +6,52 @@ import bilby
class TestNoiseRealisation(unittest.TestCase):
def test_averaged_noise(self):
- time_duration = 1.
- sampling_frequency = 4096.
+ time_duration = 1.0
+ sampling_frequency = 4096.0
factor = np.sqrt(2 / time_duration)
n_avg = 1000
psd_avg = 0
- interferometer = bilby.gw.detector.get_empty_interferometer('H1')
+ interferometer = bilby.gw.detector.get_empty_interferometer("H1")
for x in range(0, n_avg):
interferometer.set_strain_data_from_power_spectral_density(
- sampling_frequency=sampling_frequency, duration=time_duration)
- psd_avg += abs(interferometer.strain_data.frequency_domain_strain)**2
+ sampling_frequency=sampling_frequency, duration=time_duration
+ )
+ psd_avg += abs(interferometer.strain_data.frequency_domain_strain) ** 2
psd_avg = psd_avg / n_avg
asd_avg = np.sqrt(abs(psd_avg)) * interferometer.frequency_mask
- a = np.nan_to_num(interferometer.amplitude_spectral_density_array / factor * interferometer.frequency_mask)
+ a = np.nan_to_num(
+ interferometer.amplitude_spectral_density_array
+ / factor
+ * interferometer.frequency_mask
+ )
b = asd_avg
self.assertTrue(np.allclose(a, b, rtol=1e-1))
def test_noise_normalisation(self):
- duration = 1.
- sampling_frequency = 4096.
+ duration = 1.0
+ sampling_frequency = 4096.0
time_array = bilby.core.utils.create_time_series(
- sampling_frequency=sampling_frequency, duration=duration)
+ sampling_frequency=sampling_frequency, duration=duration
+ )
# generate some toy-model signal for matched filtering SNR testing
n_avg = 1000
snr = np.zeros(n_avg)
- mu = (np.exp(-(time_array-duration/2.)**2 / (2.*0.1**2))
- * np.sin(2 * np.pi * 100 * time_array))
+ mu = np.exp(-((time_array - duration / 2.0) ** 2) / (2.0 * 0.1 ** 2)) * np.sin(
+ 2 * np.pi * 100 * time_array
+ )
muf, frequency_array = bilby.core.utils.nfft(mu, sampling_frequency)
for x in range(0, n_avg):
- interferometer = bilby.gw.detector.get_empty_interferometer('H1')
+ interferometer = bilby.gw.detector.get_empty_interferometer("H1")
interferometer.set_strain_data_from_power_spectral_density(
- sampling_frequency=sampling_frequency, duration=duration)
+ sampling_frequency=sampling_frequency, duration=duration
+ )
snr[x] = interferometer.matched_filter_snr(signal=muf)
self.assertTrue(np.isclose(np.std(snr), 1.00, atol=1e-1))
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/other_test.py b/test/other_test.py
index b76e15cd37e4878222e097d0c5c7c443ced5b367..53ed7eb2462eab09221f96bddca2d8a99db5f425 100644
--- a/test/other_test.py
+++ b/test/other_test.py
@@ -10,14 +10,14 @@ import bilby
class Test(unittest.TestCase):
- outdir = './outdir'
+ outdir = "./outdir"
dir_path = os.path.dirname(os.path.realpath(__file__))
dir_path = os.path.abspath(os.path.join(dir_path, os.path.pardir))
# Run a script to produce standard data
msd = {} # A dictionary of variables saved in make_standard_data.py
- execfile(dir_path + '/test/make_standard_data.py', msd)
- '''
+ execfile(dir_path + "/test/make_standard_data.py", msd)
+ """
@classmethod
def setUpClass(self):
if os.path.isdir(self.outdir):
@@ -35,39 +35,47 @@ class Test(unittest.TestCase):
except OSError:
logging.warning(
"{} not removed prior to tests".format(self.outdir))
- '''
+ """
+
def test_make_standard_data(self):
" Load in the saved standard data and compare with new data "
# Load in the saved standard data
frequencies_saved, hf_real_saved, hf_imag_saved = np.loadtxt(
- self.dir_path + '/test/standard_data.txt').T
+ self.dir_path + "/test/standard_data.txt"
+ ).T
hf_signal_and_noise_saved = hf_real_saved + 1j * hf_imag_saved
- self.assertTrue(np.array_equal(
- self.msd['frequencies'], frequencies_saved))
- self.assertAlmostEqual(all(
- self.msd['hf_signal_and_noise'] - hf_signal_and_noise_saved),
- 0.00000000, 5)
+ self.assertTrue(np.array_equal(self.msd["frequencies"], frequencies_saved))
+ self.assertAlmostEqual(
+ all(self.msd["hf_signal_and_noise"] - hf_signal_and_noise_saved),
+ 0.00000000,
+ 5,
+ )
def test_recover_luminosity_distance(self):
likelihood = bilby.gw.likelihood.GravitationalWaveTransient(
- [self.msd['IFO']], self.msd['waveform_generator'])
+ [self.msd["IFO"]], self.msd["waveform_generator"]
+ )
priors = {}
- for key in self.msd['simulation_parameters']:
- priors[key] = self.msd['simulation_parameters'][key]
+ for key in self.msd["simulation_parameters"]:
+ priors[key] = self.msd["simulation_parameters"][key]
- dL = self.msd['simulation_parameters']['luminosity_distance']
- priors['luminosity_distance'] = bilby.core.prior.Uniform(
- name='luminosity_distance', minimum=dL - 10, maximum=dL + 10)
+ dL = self.msd["simulation_parameters"]["luminosity_distance"]
+ priors["luminosity_distance"] = bilby.core.prior.Uniform(
+ name="luminosity_distance", minimum=dL - 10, maximum=dL + 10
+ )
result = bilby.core.sampler.run_sampler(
- likelihood, priors, sampler='dynesty', verbose=False, npoints=100)
+ likelihood, priors, sampler="dynesty", verbose=False, npoints=100
+ )
self.assertAlmostEqual(
- np.mean(result.posterior.luminosity_distance), dL,
- delta=3*np.std(result.posterior.luminosity_distance))
+ np.mean(result.posterior.luminosity_distance),
+ dL,
+ delta=3 * np.std(result.posterior.luminosity_distance),
+ )
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/prior_test.py b/test/prior_test.py
index a3c5a312eddb1c2438295b8e29f2fb0c9f16a3c7..280d84b970fe209c7f92d81b6d0357fa5fad4b03 100644
--- a/test/prior_test.py
+++ b/test/prior_test.py
@@ -9,7 +9,6 @@ import scipy.stats as ss
class TestPriorInstantiationWithoutOptionalPriors(unittest.TestCase):
-
def setUp(self):
self.prior = bilby.core.prior.Prior()
@@ -41,10 +40,18 @@ class TestPriorInstantiationWithoutOptionalPriors(unittest.TestCase):
necessarily the same order as python2 doesn't conserve the order of the
arguments.
"""
- self.prior = bilby.core.prior.Prior(name='test_name', latex_label='test_label', minimum=0, maximum=1,
- check_range_nonzero=True, boundary=None)
- expected_string = "Prior(name='test_name', latex_label='test_label', unit=None, minimum=0, maximum=1, " \
- "check_range_nonzero=True, boundary=None)"
+ self.prior = bilby.core.prior.Prior(
+ name="test_name",
+ latex_label="test_label",
+ minimum=0,
+ maximum=1,
+ check_range_nonzero=True,
+ boundary=None,
+ )
+ expected_string = (
+ "Prior(name='test_name', latex_label='test_label', unit=None, minimum=0, maximum=1, "
+ "check_range_nonzero=True, boundary=None)"
+ )
self.assertTrue(sorted(expected_string) == sorted(self.prior.__repr__()))
def test_base_prob(self):
@@ -59,7 +66,7 @@ class TestPriorInstantiationWithoutOptionalPriors(unittest.TestCase):
self.prior.maximum = 1
val_below = self.prior.minimum - 0.1
val_at_minimum = self.prior.minimum
- val_in_prior = (self.prior.minimum + self.prior.maximum) / 2.
+ val_in_prior = (self.prior.minimum + self.prior.maximum) / 2.0
val_at_maximum = self.prior.maximum
val_above = self.prior.maximum + 0.1
self.assertTrue(self.prior.is_in_prior_range(val_at_minimum))
@@ -73,9 +80,8 @@ class TestPriorInstantiationWithoutOptionalPriors(unittest.TestCase):
class TestPriorName(unittest.TestCase):
-
def setUp(self):
- self.test_name = 'test_name'
+ self.test_name = "test_name"
self.prior = bilby.core.prior.Prior(self.test_name)
def tearDown(self):
@@ -89,7 +95,7 @@ class TestPriorName(unittest.TestCase):
class TestPriorLatexLabel(unittest.TestCase):
def setUp(self):
- self.test_name = 'test_name'
+ self.test_name = "test_name"
self.prior = bilby.core.prior.Prior(self.test_name)
def tearDown(self):
@@ -97,21 +103,20 @@ class TestPriorLatexLabel(unittest.TestCase):
del self.prior
def test_label_assignment(self):
- test_label = 'test_label'
- self.prior.latex_label = 'test_label'
+ test_label = "test_label"
+ self.prior.latex_label = "test_label"
self.assertEqual(test_label, self.prior.latex_label)
def test_default_label_assignment(self):
- self.prior.name = 'chirp_mass'
+ self.prior.name = "chirp_mass"
self.prior.latex_label = None
- self.assertEqual(self.prior.latex_label, '$\mathcal{M}$')
+ self.assertEqual(self.prior.latex_label, "$\mathcal{M}$")
def test_default_label_assignment_default(self):
self.assertTrue(self.prior.latex_label, self.prior.name)
class TestPriorIsFixed(unittest.TestCase):
-
def setUp(self):
pass
@@ -132,7 +137,6 @@ class TestPriorIsFixed(unittest.TestCase):
class TestPriorBoundary(unittest.TestCase):
-
def setUp(self):
self.prior = bilby.core.prior.Prior(boundary=None)
@@ -140,98 +144,208 @@ class TestPriorBoundary(unittest.TestCase):
del self.prior
def test_set_boundary_valid(self):
- self.prior.boundary = 'periodic'
- self.assertEqual(self.prior.boundary, 'periodic')
+ self.prior.boundary = "periodic"
+ self.assertEqual(self.prior.boundary, "periodic")
def test_set_boundary_invalid(self):
with self.assertRaises(ValueError):
- self.prior.boundary = 'else'
+ self.prior.boundary = "else"
class TestPriorClasses(unittest.TestCase):
-
def setUp(self):
# set multivariate Gaussian
- mvg = bilby.core.prior.MultivariateGaussianDist(names=['testa', 'testb'],
- mus=[1, 1],
- covs=np.array([[2., 0.5], [0.5, 2.]]),
- weights=1.)
- mvn = bilby.core.prior.MultivariateGaussianDist(names=['testa', 'testb'],
- mus=[1, 1],
- covs=np.array([[2., 0.5], [0.5, 2.]]),
- weights=1.)
- hp_map_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),
- 'prior_files/GW150914_testing_skymap.fits')
- hp_dist = bilby.gw.prior.HealPixMapPriorDist(hp_map_file,
- names=['testra', 'testdec'])
- hp_3d_dist = bilby.gw.prior.HealPixMapPriorDist(hp_map_file,
- names=['testra', 'testdec', 'testdistance'], distance=True)
+ mvg = bilby.core.prior.MultivariateGaussianDist(
+ names=["testa", "testb"],
+ mus=[1, 1],
+ covs=np.array([[2.0, 0.5], [0.5, 2.0]]),
+ weights=1.0,
+ )
+ mvn = bilby.core.prior.MultivariateGaussianDist(
+ names=["testa", "testb"],
+ mus=[1, 1],
+ covs=np.array([[2.0, 0.5], [0.5, 2.0]]),
+ weights=1.0,
+ )
+ hp_map_file = os.path.join(
+ os.path.dirname(os.path.realpath(__file__)),
+ "prior_files/GW150914_testing_skymap.fits",
+ )
+ hp_dist = bilby.gw.prior.HealPixMapPriorDist(
+ hp_map_file, names=["testra", "testdec"]
+ )
+ hp_3d_dist = bilby.gw.prior.HealPixMapPriorDist(
+ hp_map_file, names=["testra", "testdec", "testdistance"], distance=True
+ )
def condition_func(reference_params, test_param):
return reference_params.copy()
self.priors = [
- bilby.core.prior.DeltaFunction(name='test', unit='unit', peak=1),
- bilby.core.prior.Gaussian(name='test', unit='unit', mu=0, sigma=1),
- bilby.core.prior.Normal(name='test', unit='unit', mu=0, sigma=1),
- bilby.core.prior.PowerLaw(name='test', unit='unit', alpha=0, minimum=0, maximum=1),
- bilby.core.prior.PowerLaw(name='test', unit='unit', alpha=-1, minimum=0.5, maximum=1),
- bilby.core.prior.PowerLaw(name='test', unit='unit', alpha=2, minimum=1, maximum=1e2),
- bilby.core.prior.Uniform(name='test', unit='unit', minimum=0, maximum=1),
- bilby.core.prior.LogUniform(name='test', unit='unit', minimum=5e0, maximum=1e2),
- bilby.gw.prior.UniformComovingVolume(name='redshift', minimum=0.1, maximum=1.0),
- bilby.gw.prior.UniformSourceFrame(name='redshift', minimum=0.1, maximum=1.0),
- bilby.core.prior.Sine(name='test', unit='unit'),
- bilby.core.prior.Cosine(name='test', unit='unit'),
- bilby.core.prior.Interped(name='test', unit='unit', xx=np.linspace(0, 10, 1000),
- yy=np.linspace(0, 10, 1000) ** 4,
- minimum=3, maximum=5),
- bilby.core.prior.TruncatedGaussian(name='test', unit='unit', mu=1, sigma=0.4, minimum=-1, maximum=1),
- bilby.core.prior.TruncatedNormal(name='test', unit='unit', mu=1, sigma=0.4, minimum=-1, maximum=1),
- bilby.core.prior.HalfGaussian(name='test', unit='unit', sigma=1),
- bilby.core.prior.HalfNormal(name='test', unit='unit', sigma=1),
- bilby.core.prior.LogGaussian(name='test', unit='unit', mu=0, sigma=1),
- bilby.core.prior.LogNormal(name='test', unit='unit', mu=0, sigma=1),
- bilby.core.prior.Exponential(name='test', unit='unit', mu=1),
- bilby.core.prior.StudentT(name='test', unit='unit', df=3, mu=0, scale=1),
- bilby.core.prior.Beta(name='test', unit='unit', alpha=2.0, beta=2.0),
- bilby.core.prior.Logistic(name='test', unit='unit', mu=0, scale=1),
- bilby.core.prior.Cauchy(name='test', unit='unit', alpha=0, beta=1),
- bilby.core.prior.Lorentzian(name='test', unit='unit', alpha=0, beta=1),
- bilby.core.prior.Gamma(name='test', unit='unit', k=1, theta=1),
- bilby.core.prior.ChiSquared(name='test', unit='unit', nu=2),
- bilby.gw.prior.AlignedSpin(name='test', unit='unit'),
- bilby.core.prior.MultivariateGaussian(dist=mvg, name='testa', unit='unit'),
- bilby.core.prior.MultivariateGaussian(dist=mvg, name='testb', unit='unit'),
- bilby.core.prior.MultivariateNormal(dist=mvn, name='testa', unit='unit'),
- bilby.core.prior.MultivariateNormal(dist=mvn, name='testb', unit='unit'),
- bilby.core.prior.ConditionalDeltaFunction(condition_func=condition_func, name='test', unit='unit', peak=1),
- bilby.core.prior.ConditionalGaussian(condition_func=condition_func, name='test', unit='unit', mu=0, sigma=1),
- bilby.core.prior.ConditionalPowerLaw(condition_func=condition_func, name='test', unit='unit', alpha=0, minimum=0, maximum=1),
- bilby.core.prior.ConditionalPowerLaw(condition_func=condition_func, name='test', unit='unit', alpha=-1, minimum=0.5, maximum=1),
- bilby.core.prior.ConditionalPowerLaw(condition_func=condition_func, name='test', unit='unit', alpha=2, minimum=1, maximum=1e2),
- bilby.core.prior.ConditionalUniform(condition_func=condition_func, name='test', unit='unit', minimum=0, maximum=1),
- bilby.core.prior.ConditionalLogUniform(condition_func=condition_func, name='test', unit='unit', minimum=5e0, maximum=1e2),
- bilby.gw.prior.ConditionalUniformComovingVolume(condition_func=condition_func, name='redshift', minimum=0.1, maximum=1.0),
- bilby.gw.prior.ConditionalUniformSourceFrame(condition_func=condition_func, name='redshift', minimum=0.1, maximum=1.0),
- bilby.core.prior.ConditionalSine(condition_func=condition_func, name='test', unit='unit'),
- bilby.core.prior.ConditionalCosine(condition_func=condition_func, name='test', unit='unit'),
- bilby.core.prior.ConditionalTruncatedGaussian(condition_func=condition_func, name='test', unit='unit', mu=1, sigma=0.4, minimum=-1, maximum=1),
- bilby.core.prior.ConditionalHalfGaussian(condition_func=condition_func, name='test', unit='unit', sigma=1),
- bilby.core.prior.ConditionalLogNormal(condition_func=condition_func, name='test', unit='unit', mu=0, sigma=1),
- bilby.core.prior.ConditionalExponential(condition_func=condition_func, name='test', unit='unit', mu=1),
- bilby.core.prior.ConditionalStudentT(condition_func=condition_func, name='test', unit='unit', df=3, mu=0, scale=1),
- bilby.core.prior.ConditionalBeta(condition_func=condition_func, name='test', unit='unit', alpha=2.0, beta=2.0),
- bilby.core.prior.ConditionalLogistic(condition_func=condition_func, name='test', unit='unit', mu=0, scale=1),
- bilby.core.prior.ConditionalCauchy(condition_func=condition_func, name='test', unit='unit', alpha=0, beta=1),
- bilby.core.prior.ConditionalGamma(condition_func=condition_func, name='test', unit='unit', k=1, theta=1),
- bilby.core.prior.ConditionalChiSquared(condition_func=condition_func, name='test', unit='unit', nu=2),
- bilby.gw.prior.HealPixPrior(dist=hp_dist, name='testra', unit='unit'),
- bilby.gw.prior.HealPixPrior(dist=hp_dist, name='testdec', unit='unit'),
- bilby.gw.prior.HealPixPrior(dist=hp_3d_dist, name='testra', unit='unit'),
- bilby.gw.prior.HealPixPrior(dist=hp_3d_dist, name='testdec', unit='unit'),
- bilby.gw.prior.HealPixPrior(dist=hp_3d_dist, name='testdistance', unit='unit')
+ bilby.core.prior.DeltaFunction(name="test", unit="unit", peak=1),
+ bilby.core.prior.Gaussian(name="test", unit="unit", mu=0, sigma=1),
+ bilby.core.prior.Normal(name="test", unit="unit", mu=0, sigma=1),
+ bilby.core.prior.PowerLaw(
+ name="test", unit="unit", alpha=0, minimum=0, maximum=1
+ ),
+ bilby.core.prior.PowerLaw(
+ name="test", unit="unit", alpha=-1, minimum=0.5, maximum=1
+ ),
+ bilby.core.prior.PowerLaw(
+ name="test", unit="unit", alpha=2, minimum=1, maximum=1e2
+ ),
+ bilby.core.prior.Uniform(name="test", unit="unit", minimum=0, maximum=1),
+ bilby.core.prior.LogUniform(
+ name="test", unit="unit", minimum=5e0, maximum=1e2
+ ),
+ bilby.gw.prior.UniformComovingVolume(
+ name="redshift", minimum=0.1, maximum=1.0
+ ),
+ bilby.gw.prior.UniformSourceFrame(
+ name="redshift", minimum=0.1, maximum=1.0
+ ),
+ bilby.core.prior.Sine(name="test", unit="unit"),
+ bilby.core.prior.Cosine(name="test", unit="unit"),
+ bilby.core.prior.Interped(
+ name="test",
+ unit="unit",
+ xx=np.linspace(0, 10, 1000),
+ yy=np.linspace(0, 10, 1000) ** 4,
+ minimum=3,
+ maximum=5,
+ ),
+ bilby.core.prior.TruncatedGaussian(
+ name="test", unit="unit", mu=1, sigma=0.4, minimum=-1, maximum=1
+ ),
+ bilby.core.prior.TruncatedNormal(
+ name="test", unit="unit", mu=1, sigma=0.4, minimum=-1, maximum=1
+ ),
+ bilby.core.prior.HalfGaussian(name="test", unit="unit", sigma=1),
+ bilby.core.prior.HalfNormal(name="test", unit="unit", sigma=1),
+ bilby.core.prior.LogGaussian(name="test", unit="unit", mu=0, sigma=1),
+ bilby.core.prior.LogNormal(name="test", unit="unit", mu=0, sigma=1),
+ bilby.core.prior.Exponential(name="test", unit="unit", mu=1),
+ bilby.core.prior.StudentT(name="test", unit="unit", df=3, mu=0, scale=1),
+ bilby.core.prior.Beta(name="test", unit="unit", alpha=2.0, beta=2.0),
+ bilby.core.prior.Logistic(name="test", unit="unit", mu=0, scale=1),
+ bilby.core.prior.Cauchy(name="test", unit="unit", alpha=0, beta=1),
+ bilby.core.prior.Lorentzian(name="test", unit="unit", alpha=0, beta=1),
+ bilby.core.prior.Gamma(name="test", unit="unit", k=1, theta=1),
+ bilby.core.prior.ChiSquared(name="test", unit="unit", nu=2),
+ bilby.gw.prior.AlignedSpin(name="test", unit="unit"),
+ bilby.core.prior.MultivariateGaussian(dist=mvg, name="testa", unit="unit"),
+ bilby.core.prior.MultivariateGaussian(dist=mvg, name="testb", unit="unit"),
+ bilby.core.prior.MultivariateNormal(dist=mvn, name="testa", unit="unit"),
+ bilby.core.prior.MultivariateNormal(dist=mvn, name="testb", unit="unit"),
+ bilby.core.prior.ConditionalDeltaFunction(
+ condition_func=condition_func, name="test", unit="unit", peak=1
+ ),
+ bilby.core.prior.ConditionalGaussian(
+ condition_func=condition_func, name="test", unit="unit", mu=0, sigma=1
+ ),
+ bilby.core.prior.ConditionalPowerLaw(
+ condition_func=condition_func,
+ name="test",
+ unit="unit",
+ alpha=0,
+ minimum=0,
+ maximum=1,
+ ),
+ bilby.core.prior.ConditionalPowerLaw(
+ condition_func=condition_func,
+ name="test",
+ unit="unit",
+ alpha=-1,
+ minimum=0.5,
+ maximum=1,
+ ),
+ bilby.core.prior.ConditionalPowerLaw(
+ condition_func=condition_func,
+ name="test",
+ unit="unit",
+ alpha=2,
+ minimum=1,
+ maximum=1e2,
+ ),
+ bilby.core.prior.ConditionalUniform(
+ condition_func=condition_func,
+ name="test",
+ unit="unit",
+ minimum=0,
+ maximum=1,
+ ),
+ bilby.core.prior.ConditionalLogUniform(
+ condition_func=condition_func,
+ name="test",
+ unit="unit",
+ minimum=5e0,
+ maximum=1e2,
+ ),
+ bilby.gw.prior.ConditionalUniformComovingVolume(
+ condition_func=condition_func, name="redshift", minimum=0.1, maximum=1.0
+ ),
+ bilby.gw.prior.ConditionalUniformSourceFrame(
+ condition_func=condition_func, name="redshift", minimum=0.1, maximum=1.0
+ ),
+ bilby.core.prior.ConditionalSine(
+ condition_func=condition_func, name="test", unit="unit"
+ ),
+ bilby.core.prior.ConditionalCosine(
+ condition_func=condition_func, name="test", unit="unit"
+ ),
+ bilby.core.prior.ConditionalTruncatedGaussian(
+ condition_func=condition_func,
+ name="test",
+ unit="unit",
+ mu=1,
+ sigma=0.4,
+ minimum=-1,
+ maximum=1,
+ ),
+ bilby.core.prior.ConditionalHalfGaussian(
+ condition_func=condition_func, name="test", unit="unit", sigma=1
+ ),
+ bilby.core.prior.ConditionalLogNormal(
+ condition_func=condition_func, name="test", unit="unit", mu=0, sigma=1
+ ),
+ bilby.core.prior.ConditionalExponential(
+ condition_func=condition_func, name="test", unit="unit", mu=1
+ ),
+ bilby.core.prior.ConditionalStudentT(
+ condition_func=condition_func,
+ name="test",
+ unit="unit",
+ df=3,
+ mu=0,
+ scale=1,
+ ),
+ bilby.core.prior.ConditionalBeta(
+ condition_func=condition_func,
+ name="test",
+ unit="unit",
+ alpha=2.0,
+ beta=2.0,
+ ),
+ bilby.core.prior.ConditionalLogistic(
+ condition_func=condition_func, name="test", unit="unit", mu=0, scale=1
+ ),
+ bilby.core.prior.ConditionalCauchy(
+ condition_func=condition_func, name="test", unit="unit", alpha=0, beta=1
+ ),
+ bilby.core.prior.ConditionalGamma(
+ condition_func=condition_func, name="test", unit="unit", k=1, theta=1
+ ),
+ bilby.core.prior.ConditionalChiSquared(
+ condition_func=condition_func, name="test", unit="unit", nu=2
+ ),
+ bilby.gw.prior.HealPixPrior(dist=hp_dist, name="testra", unit="unit"),
+ bilby.gw.prior.HealPixPrior(dist=hp_dist, name="testdec", unit="unit"),
+ bilby.gw.prior.HealPixPrior(dist=hp_3d_dist, name="testra", unit="unit"),
+ bilby.gw.prior.HealPixPrior(dist=hp_3d_dist, name="testdec", unit="unit"),
+ bilby.gw.prior.HealPixPrior(
+ dist=hp_3d_dist, name="testdistance", unit="unit"
+ ),
]
def tearDown(self):
@@ -268,7 +382,9 @@ class TestPriorClasses(unittest.TestCase):
if bilby.core.prior.JointPrior in prior.__class__.__mro__:
if not prior.dist.filled_rescale():
continue
- self.assertTrue(all((many_samples >= prior.minimum) & (many_samples <= prior.maximum)))
+ self.assertTrue(
+ all((many_samples >= prior.minimum) & (many_samples <= prior.maximum))
+ )
def test_out_of_bounds_rescaling(self):
"""Test the the rescaling works as expected."""
@@ -278,25 +394,34 @@ class TestPriorClasses(unittest.TestCase):
def test_least_recently_sampled(self):
for prior in self.priors:
least_recently_sampled_expected = prior.sample()
- self.assertEqual(least_recently_sampled_expected, prior.least_recently_sampled)
+ self.assertEqual(
+ least_recently_sampled_expected, prior.least_recently_sampled
+ )
def test_sampling_single(self):
"""Test that sampling from the prior always returns values within its domain."""
for prior in self.priors:
single_sample = prior.sample()
- self.assertTrue((single_sample >= prior.minimum) & (single_sample <= prior.maximum))
+ self.assertTrue(
+ (single_sample >= prior.minimum) & (single_sample <= prior.maximum)
+ )
def test_sampling_many(self):
"""Test that sampling from the prior always returns values within its domain."""
for prior in self.priors:
many_samples = prior.sample(5000)
- self.assertTrue((all(many_samples >= prior.minimum)) & (all(many_samples <= prior.maximum)))
+ self.assertTrue(
+ (all(many_samples >= prior.minimum))
+ & (all(many_samples <= prior.maximum))
+ )
def test_probability_above_domain(self):
"""Test that the prior probability is non-negative in domain of validity and zero outside."""
for prior in self.priors:
if prior.maximum != np.inf:
- outside_domain = np.linspace(prior.maximum + 1, prior.maximum + 1e4, 1000)
+ outside_domain = np.linspace(
+ prior.maximum + 1, prior.maximum + 1e4, 1000
+ )
if bilby.core.prior.JointPrior in prior.__class__.__mro__:
if not prior.dist.filled_request():
prior.dist.requested_parameters[prior.name] = outside_domain
@@ -307,14 +432,16 @@ class TestPriorClasses(unittest.TestCase):
"""Test that the prior probability is non-negative in domain of validity and zero outside."""
for prior in self.priors:
if prior.minimum != -np.inf:
- outside_domain = np.linspace(prior.minimum - 1e4, prior.minimum - 1, 1000)
+ outside_domain = np.linspace(
+ prior.minimum - 1e4, prior.minimum - 1, 1000
+ )
if bilby.core.prior.JointPrior in prior.__class__.__mro__:
if not prior.dist.filled_request():
prior.dist.requested_parameters[prior.name] = outside_domain
continue
self.assertTrue(all(prior.prob(outside_domain) == 0))
- def test_least_recently_sampled(self):
+ def test_least_recently_sampled_2(self):
for prior in self.priors:
lrs = prior.sample()
self.assertEqual(lrs, prior.least_recently_sampled)
@@ -322,15 +449,17 @@ class TestPriorClasses(unittest.TestCase):
def test_prob_and_ln_prob(self):
for prior in self.priors:
sample = prior.sample()
- if not bilby.core.prior.JointPrior in prior.__class__.__mro__:
+ if not bilby.core.prior.JointPrior in prior.__class__.__mro__: # noqa
# due to the way that the Multivariate Gaussian prior must sequentially call
# the prob and ln_prob functions, it must be ignored in this test.
- self.assertAlmostEqual(np.log(prior.prob(sample)), prior.ln_prob(sample), 12)
+ self.assertAlmostEqual(
+ np.log(prior.prob(sample)), prior.ln_prob(sample), 12
+ )
def test_many_prob_and_many_ln_prob(self):
for prior in self.priors:
samples = prior.sample(10)
- if not bilby.core.prior.JointPrior in prior.__class__.__mro__:
+ if not bilby.core.prior.JointPrior in prior.__class__.__mro__: # noqa
ln_probs = prior.ln_prob(samples)
probs = prior.prob(samples)
for sample, logp, p in zip(samples, ln_probs, probs):
@@ -341,8 +470,10 @@ class TestPriorClasses(unittest.TestCase):
domain = np.linspace(0, 1, 100)
threshold = 1e-9
for prior in self.priors:
- if isinstance(prior, bilby.core.prior.DeltaFunction) or \
- bilby.core.prior.JointPrior in prior.__class__.__mro__:
+ if (
+ isinstance(prior, bilby.core.prior.DeltaFunction)
+ or bilby.core.prior.JointPrior in prior.__class__.__mro__
+ ):
continue
rescaled = prior.rescale(domain)
max_difference = max(np.abs(domain - prior.cdf(rescaled)))
@@ -352,136 +483,155 @@ class TestPriorClasses(unittest.TestCase):
for prior in self.priors:
if prior.maximum != np.inf:
outside_domain = np.linspace(
- prior.maximum + 1, prior.maximum + 1e4, 1000)
+ prior.maximum + 1, prior.maximum + 1e4, 1000
+ )
self.assertTrue(all(prior.cdf(outside_domain) == 1))
def test_cdf_zero_below_domain(self):
for prior in self.priors:
- if bilby.core.prior.JointPrior in prior.__class__.__mro__ and prior.maximum == np.inf:
+ if (
+ bilby.core.prior.JointPrior in prior.__class__.__mro__
+ and prior.maximum == np.inf
+ ):
continue
if prior.minimum != -np.inf:
outside_domain = np.linspace(
- prior.minimum - 1e4, prior.minimum - 1, 1000)
- self.assertTrue(all(
- np.nan_to_num(prior.cdf(outside_domain)) == 0))
+ prior.minimum - 1e4, prior.minimum - 1, 1000
+ )
+ self.assertTrue(all(np.nan_to_num(prior.cdf(outside_domain)) == 0))
def test_log_normal_fail(self):
with self.assertRaises(ValueError):
- bilby.core.prior.LogNormal(name='test', unit='unit', mu=0, sigma=-1)
+ bilby.core.prior.LogNormal(name="test", unit="unit", mu=0, sigma=-1)
def test_studentt_fail(self):
with self.assertRaises(ValueError):
- bilby.core.prior.StudentT(name='test', unit='unit', df=3, mu=0, scale=-1)
+ bilby.core.prior.StudentT(name="test", unit="unit", df=3, mu=0, scale=-1)
with self.assertRaises(ValueError):
- bilby.core.prior.StudentT(name='test', unit='unit', df=0, mu=0, scale=1)
+ bilby.core.prior.StudentT(name="test", unit="unit", df=0, mu=0, scale=1)
def test_beta_fail(self):
with self.assertRaises(ValueError):
- bilby.core.prior.Beta(name='test', unit='unit', alpha=-2.0, beta=2.0),
+ bilby.core.prior.Beta(name="test", unit="unit", alpha=-2.0, beta=2.0),
with self.assertRaises(ValueError):
- bilby.core.prior.Beta(name='test', unit='unit', alpha=2.0, beta=-2.0),
+ bilby.core.prior.Beta(name="test", unit="unit", alpha=2.0, beta=-2.0),
def test_multivariate_gaussian_fail(self):
with self.assertRaises(ValueError):
# bounds is wrong length
- bilby.core.prior.MultivariateGaussianDist(['a', 'b'],
- bounds=[(-1., 1.)])
+ bilby.core.prior.MultivariateGaussianDist(["a", "b"], bounds=[(-1.0, 1.0)])
with self.assertRaises(ValueError):
# bounds has lower value greater than upper
- bilby.core.prior.MultivariateGaussianDist(['a', 'b'],
- bounds=[(-1., 1.), (1., -1)])
+ bilby.core.prior.MultivariateGaussianDist(
+ ["a", "b"], bounds=[(-1.0, 1.0), (1.0, -1)]
+ )
with self.assertRaises(TypeError):
# bound is not a list/tuple
- bilby.core.prior.MultivariateGaussianDist(['a', 'b'],
- bounds=[(-1., 1.), 2])
+ bilby.core.prior.MultivariateGaussianDist(
+ ["a", "b"], bounds=[(-1.0, 1.0), 2]
+ )
with self.assertRaises(ValueError):
# bound contains too many values
- bilby.core.prior.MultivariateGaussianDist(['a', 'b'],
- bounds=[(-1., 1., 4), 2])
+ bilby.core.prior.MultivariateGaussianDist(
+ ["a", "b"], bounds=[(-1.0, 1.0, 4), 2]
+ )
with self.assertRaises(ValueError):
# means is not a list
- bilby.core.prior.MultivariateGaussianDist(['a', 'b'], mus=1.)
+ bilby.core.prior.MultivariateGaussianDist(["a", "b"], mus=1.0)
with self.assertRaises(ValueError):
# sigmas is not a list
- bilby.core.prior.MultivariateGaussianDist(['a', 'b'], sigmas=1.)
+ bilby.core.prior.MultivariateGaussianDist(["a", "b"], sigmas=1.0)
with self.assertRaises(TypeError):
# covariances is not a list
- bilby.core.prior.MultivariateGaussianDist(['a', 'b'], covs=1.)
+ bilby.core.prior.MultivariateGaussianDist(["a", "b"], covs=1.0)
with self.assertRaises(TypeError):
# correlation coefficients is not a list
- bilby.core.prior.MultivariateGaussianDist(['a', 'b'], corrcoefs=1.)
+ bilby.core.prior.MultivariateGaussianDist(["a", "b"], corrcoefs=1.0)
with self.assertRaises(ValueError):
# wrong number of weights
- bilby.core.prior.MultivariateGaussianDist(['a', 'b'], weights=[0.5, 0.5])
+ bilby.core.prior.MultivariateGaussianDist(["a", "b"], weights=[0.5, 0.5])
with self.assertRaises(ValueError):
# not enough modes set
- bilby.core.prior.MultivariateGaussianDist(['a', 'b'], mus=[[1., 2.]],
- nmodes=2)
+ bilby.core.prior.MultivariateGaussianDist(
+ ["a", "b"], mus=[[1.0, 2.0]], nmodes=2
+ )
with self.assertRaises(ValueError):
# covariance is the wrong shape
- bilby.core.prior.MultivariateGaussianDist(['a', 'b'],
- covs=np.array([[[1., 1.],
- [1., 1.]]]))
+ bilby.core.prior.MultivariateGaussianDist(
+ ["a", "b"], covs=np.array([[[1.0, 1.0], [1.0, 1.0]]])
+ )
with self.assertRaises(ValueError):
# covariance is the wrong shape
- bilby.core.prior.MultivariateGaussianDist(['a', 'b'],
- covs=np.array([[[1., 1.]]]))
+ bilby.core.prior.MultivariateGaussianDist(
+ ["a", "b"], covs=np.array([[[1.0, 1.0]]])
+ )
with self.assertRaises(ValueError):
# correlation coefficient matrix is the wrong shape
- bilby.core.prior.MultivariateGaussianDist(['a', 'b'], sigmas=[1., 1.],
- corrcoefs=np.array([[[[1., 1.],
- [1., 1.]]]]))
+ bilby.core.prior.MultivariateGaussianDist(
+ ["a", "b"],
+ sigmas=[1.0, 1.0],
+ corrcoefs=np.array([[[[1.0, 1.0], [1.0, 1.0]]]]),
+ )
with self.assertRaises(ValueError):
# correlation coefficient matrix is the wrong shape
- bilby.core.prior.MultivariateGaussianDist(['a', 'b'], sigmas=[1., 1.],
- corrcoefs=np.array([[[1., 1.]]]))
+ bilby.core.prior.MultivariateGaussianDist(
+ ["a", "b"], sigmas=[1.0, 1.0], corrcoefs=np.array([[[1.0, 1.0]]])
+ )
with self.assertRaises(ValueError):
# correlation coefficient has non-unity diagonal value
- bilby.core.prior.MultivariateGaussianDist(['a', 'b'], sigmas=[1., 1.],
- corrcoefs=np.array([[1., 1.],
- [1., 2.]]))
+ bilby.core.prior.MultivariateGaussianDist(
+ ["a", "b"],
+ sigmas=[1.0, 1.0],
+ corrcoefs=np.array([[1.0, 1.0], [1.0, 2.0]]),
+ )
with self.assertRaises(ValueError):
# correlation coefficient matrix is not symmetric
- bilby.core.prior.MultivariateGaussianDist(['a', 'b'], sigmas=[1., 2.],
- corrcoefs=np.array([[1., -1.2],
- [-0.3, 1.]]))
+ bilby.core.prior.MultivariateGaussianDist(
+ ["a", "b"],
+ sigmas=[1.0, 2.0],
+ corrcoefs=np.array([[1.0, -1.2], [-0.3, 1.0]]),
+ )
with self.assertRaises(ValueError):
# correlation coefficient matrix is not positive definite
- bilby.core.prior.MultivariateGaussianDist(['a', 'b'], sigmas=[1., 2.],
- corrcoefs=np.array([[1., -1.3],
- [-1.3, 1.]]))
+ bilby.core.prior.MultivariateGaussianDist(
+ ["a", "b"],
+ sigmas=[1.0, 2.0],
+ corrcoefs=np.array([[1.0, -1.3], [-1.3, 1.0]]),
+ )
with self.assertRaises(ValueError):
# wrong number of sigmas
- bilby.core.prior.MultivariateGaussianDist(['a', 'b'], sigmas=[1., 2., 3.],
- corrcoefs=np.array([[1., 0.3],
- [0.3, 1.]]))
+ bilby.core.prior.MultivariateGaussianDist(
+ ["a", "b"],
+ sigmas=[1.0, 2.0, 3.0],
+ corrcoefs=np.array([[1.0, 0.3], [0.3, 1.0]]),
+ )
def test_multivariate_gaussian_covariance(self):
"""Test that the correlation coefficient/covariance matrices are correct"""
- cov = np.array([[4., 0], [0., 9.]])
- mvg = bilby.core.prior.MultivariateGaussianDist(['a', 'b'], covs=cov)
+ cov = np.array([[4.0, 0], [0.0, 9.0]])
+ mvg = bilby.core.prior.MultivariateGaussianDist(["a", "b"], covs=cov)
self.assertEqual(mvg.nmodes, 1)
self.assertTrue(np.allclose(mvg.covs[0], cov))
self.assertTrue(np.allclose(mvg.sigmas[0], np.sqrt(np.diag(cov))))
self.assertTrue(np.allclose(mvg.corrcoefs[0], np.eye(2)))
- corrcoef = np.array([[1., 0.5], [0.5, 1.]])
- sigma = [2., 2.]
- mvg = bilby.core.prior.MultivariateGaussianDist(['a', 'b'],
- corrcoefs=corrcoef,
- sigmas=sigma)
+ corrcoef = np.array([[1.0, 0.5], [0.5, 1.0]])
+ sigma = [2.0, 2.0]
+ mvg = bilby.core.prior.MultivariateGaussianDist(
+ ["a", "b"], corrcoefs=corrcoef, sigmas=sigma
+ )
self.assertTrue(np.allclose(mvg.corrcoefs[0], corrcoef))
self.assertTrue(np.allclose(mvg.sigmas[0], sigma))
self.assertTrue(np.allclose(np.diag(mvg.covs[0]), np.square(sigma)))
- self.assertTrue(np.allclose(np.diag(np.fliplr(mvg.covs[0])), 2.*np.ones(2)))
+ self.assertTrue(np.allclose(np.diag(np.fliplr(mvg.covs[0])), 2.0 * np.ones(2)))
def test_fermidirac_fail(self):
with self.assertRaises(ValueError):
- bilby.core.prior.FermiDirac(name='test', unit='unit', sigma=1.)
+ bilby.core.prior.FermiDirac(name="test", unit="unit", sigma=1.0)
with self.assertRaises(ValueError):
- bilby.core.prior.FermiDirac(name='test', unit='unit', sigma=1., mu=-1)
+ bilby.core.prior.FermiDirac(name="test", unit="unit", sigma=1.0, mu=-1)
def test_probability_in_domain(self):
"""Test that the prior probability is non-negative in domain of validity and zero outside."""
@@ -500,8 +650,12 @@ class TestPriorClasses(unittest.TestCase):
if isinstance(prior, bilby.core.prior.DeltaFunction):
continue
surround_domain = np.linspace(prior.minimum - 1, prior.maximum + 1, 1000)
- indomain = (surround_domain >= prior.minimum) | (surround_domain <= prior.maximum)
- outdomain = (surround_domain < prior.minimum) | (surround_domain > prior.maximum)
+ indomain = (surround_domain >= prior.minimum) | (
+ surround_domain <= prior.maximum
+ )
+ outdomain = (surround_domain < prior.minimum) | (
+ surround_domain > prior.maximum
+ )
if bilby.core.prior.JointPrior in prior.__class__.__mro__:
if not prior.dist.filled_request():
continue
@@ -524,17 +678,17 @@ class TestPriorClasses(unittest.TestCase):
elif isinstance(prior, bilby.core.prior.StudentT):
domain = np.linspace(-1e2, 1e2, 1000)
elif isinstance(prior, bilby.core.prior.HalfGaussian):
- domain = np.linspace(0., 1e2, 1000)
+ domain = np.linspace(0.0, 1e2, 1000)
elif isinstance(prior, bilby.core.prior.Gamma):
- domain = np.linspace(0., 1e2, 5000)
+ domain = np.linspace(0.0, 1e2, 5000)
elif isinstance(prior, bilby.core.prior.LogNormal):
- domain = np.linspace(0., 1e2, 1000)
+ domain = np.linspace(0.0, 1e2, 1000)
elif isinstance(prior, bilby.core.prior.Exponential):
- domain = np.linspace(0., 1e2, 5000)
+ domain = np.linspace(0.0, 1e2, 5000)
elif isinstance(prior, bilby.core.prior.Logistic):
domain = np.linspace(-1e2, 1e2, 1000)
elif isinstance(prior, bilby.core.prior.FermiDirac):
- domain = np.linspace(0., 1e2, 1000)
+ domain = np.linspace(0.0, 1e2, 1000)
else:
domain = np.linspace(prior.minimum, prior.maximum, 1000)
self.assertAlmostEqual(np.trapz(prior.prob(domain), domain), 1, 3)
@@ -567,21 +721,22 @@ class TestPriorClasses(unittest.TestCase):
scipy_lnprob = ss.t.logpdf(domain, 3, loc=0, scale=1)
scipy_cdf = ss.t.cdf(domain, 3, loc=0, scale=1)
scipy_rescale = ss.t.ppf(rescale_domain, 3, loc=0, scale=1)
- elif (isinstance(prior, bilby.core.prior.Gamma) and
- not isinstance(prior, bilby.core.prior.ChiSquared)):
- domain = np.linspace(0., 1e2, 5000)
+ elif isinstance(prior, bilby.core.prior.Gamma) and not isinstance(
+ prior, bilby.core.prior.ChiSquared
+ ):
+ domain = np.linspace(0.0, 1e2, 5000)
scipy_prob = ss.gamma.pdf(domain, 1, loc=0, scale=1)
scipy_lnprob = ss.gamma.logpdf(domain, 1, loc=0, scale=1)
scipy_cdf = ss.gamma.cdf(domain, 1, loc=0, scale=1)
scipy_rescale = ss.gamma.ppf(rescale_domain, 1, loc=0, scale=1)
elif isinstance(prior, bilby.core.prior.LogNormal):
- domain = np.linspace(0., 1e2, 1000)
+ domain = np.linspace(0.0, 1e2, 1000)
scipy_prob = ss.lognorm.pdf(domain, 1, scale=1)
scipy_lnprob = ss.lognorm.logpdf(domain, 1, scale=1)
scipy_cdf = ss.lognorm.cdf(domain, 1, scale=1)
scipy_rescale = ss.lognorm.ppf(rescale_domain, 1, scale=1)
elif isinstance(prior, bilby.core.prior.Exponential):
- domain = np.linspace(0., 1e2, 5000)
+ domain = np.linspace(0.0, 1e2, 5000)
scipy_prob = ss.expon.pdf(domain, scale=1)
scipy_lnprob = ss.expon.logpdf(domain, scale=1)
scipy_cdf = ss.expon.cdf(domain, scale=1)
@@ -593,7 +748,7 @@ class TestPriorClasses(unittest.TestCase):
scipy_cdf = ss.logistic.cdf(domain, loc=0, scale=1)
scipy_rescale = ss.logistic.ppf(rescale_domain, loc=0, scale=1)
elif isinstance(prior, bilby.core.prior.ChiSquared):
- domain = np.linspace(0., 1e2, 5000)
+ domain = np.linspace(0.0, 1e2, 5000)
scipy_prob = ss.gamma.pdf(domain, 1, loc=0, scale=2)
scipy_lnprob = ss.gamma.logpdf(domain, 1, loc=0, scale=2)
scipy_cdf = ss.gamma.cdf(domain, 1, loc=0, scale=2)
@@ -607,23 +762,30 @@ class TestPriorClasses(unittest.TestCase):
else:
continue
testTuple = (
- bilby.core.prior.Uniform, bilby.core.prior.Gaussian,
- bilby.core.prior.Cauchy, bilby.core.prior.StudentT,
- bilby.core.prior.Exponential, bilby.core.prior.Logistic,
- bilby.core.prior.LogNormal, bilby.core.prior.Gamma,
- bilby.core.prior.Beta)
+ bilby.core.prior.Uniform,
+ bilby.core.prior.Gaussian,
+ bilby.core.prior.Cauchy,
+ bilby.core.prior.StudentT,
+ bilby.core.prior.Exponential,
+ bilby.core.prior.Logistic,
+ bilby.core.prior.LogNormal,
+ bilby.core.prior.Gamma,
+ bilby.core.prior.Beta,
+ )
if isinstance(prior, (testTuple)):
np.testing.assert_almost_equal(prior.prob(domain), scipy_prob)
np.testing.assert_almost_equal(prior.ln_prob(domain), scipy_lnprob)
np.testing.assert_almost_equal(prior.cdf(domain), scipy_cdf)
- np.testing.assert_almost_equal(prior.rescale(rescale_domain), scipy_rescale)
+ np.testing.assert_almost_equal(
+ prior.rescale(rescale_domain), scipy_rescale
+ )
def test_unit_setting(self):
for prior in self.priors:
if isinstance(prior, bilby.gw.prior.Cosmological):
self.assertEqual(None, prior.unit)
else:
- self.assertEqual('unit', prior.unit)
+ self.assertEqual("unit", prior.unit)
def test_eq_different_classes(self):
for i in range(len(self.priors)):
@@ -634,19 +796,31 @@ class TestPriorClasses(unittest.TestCase):
self.assertNotEqual(self.priors[i], self.priors[j])
def test_eq_other_condition(self):
- prior_1 = bilby.core.prior.PowerLaw(name='test', unit='unit', alpha=0, minimum=0, maximum=1)
- prior_2 = bilby.core.prior.PowerLaw(name='test', unit='unit', alpha=0, minimum=0, maximum=1.5)
+ prior_1 = bilby.core.prior.PowerLaw(
+ name="test", unit="unit", alpha=0, minimum=0, maximum=1
+ )
+ prior_2 = bilby.core.prior.PowerLaw(
+ name="test", unit="unit", alpha=0, minimum=0, maximum=1.5
+ )
self.assertNotEqual(prior_1, prior_2)
def test_eq_different_keys(self):
- prior_1 = bilby.core.prior.PowerLaw(name='test', unit='unit', alpha=0, minimum=0, maximum=1)
- prior_2 = bilby.core.prior.PowerLaw(name='test', unit='unit', alpha=0, minimum=0, maximum=1)
+ prior_1 = bilby.core.prior.PowerLaw(
+ name="test", unit="unit", alpha=0, minimum=0, maximum=1
+ )
+ prior_2 = bilby.core.prior.PowerLaw(
+ name="test", unit="unit", alpha=0, minimum=0, maximum=1
+ )
prior_2.other_key = 5
self.assertNotEqual(prior_1, prior_2)
def test_np_array_eq(self):
- prior_1 = bilby.core.prior.PowerLaw(name='test', unit='unit', alpha=0, minimum=0, maximum=1)
- prior_2 = bilby.core.prior.PowerLaw(name='test', unit='unit', alpha=0, minimum=0, maximum=1)
+ prior_1 = bilby.core.prior.PowerLaw(
+ name="test", unit="unit", alpha=0, minimum=0, maximum=1
+ )
+ prior_2 = bilby.core.prior.PowerLaw(
+ name="test", unit="unit", alpha=0, minimum=0, maximum=1
+ )
prior_1.array_attribute = np.array([1, 2, 3])
prior_2.array_attribute = np.array([2, 2, 3])
self.assertNotEqual(prior_1, prior_2)
@@ -656,65 +830,92 @@ class TestPriorClasses(unittest.TestCase):
if isinstance(prior, bilby.core.prior.Interped):
continue # we cannot test this because of the numpy arrays
elif isinstance(prior, bilby.core.prior.MultivariateGaussian):
- repr_prior_string = 'bilby.core.prior.' + repr(prior)
+ repr_prior_string = "bilby.core.prior." + repr(prior)
repr_prior_string = repr_prior_string.replace(
- 'MultivariateGaussianDist',
- 'bilby.core.prior.MultivariateGaussianDist'
+ "MultivariateGaussianDist",
+ "bilby.core.prior.MultivariateGaussianDist",
)
elif isinstance(prior, bilby.gw.prior.HealPixPrior):
- repr_prior_string = 'bilby.gw.prior.'+repr(prior)
- repr_prior_string = repr_prior_string.replace('HealPixMapPriorDist',
- 'bilby.gw.prior.HealPixMapPriorDist')
+ repr_prior_string = "bilby.gw.prior." + repr(prior)
+ repr_prior_string = repr_prior_string.replace(
+ "HealPixMapPriorDist", "bilby.gw.prior.HealPixMapPriorDist"
+ )
elif isinstance(prior, bilby.gw.prior.UniformComovingVolume):
- repr_prior_string = 'bilby.gw.prior.' + repr(prior)
- elif 'Conditional' in prior.__class__.__name__:
- continue # This feature does not exist because we cannot recreate the condition function
+ repr_prior_string = "bilby.gw.prior." + repr(prior)
+ elif "Conditional" in prior.__class__.__name__:
+ continue # This feature does not exist because we cannot recreate the condition function
else:
- repr_prior_string = 'bilby.core.prior.' + repr(prior)
+ repr_prior_string = "bilby.core.prior." + repr(prior)
repr_prior = eval(repr_prior_string, None, dict(inf=np.inf))
self.assertEqual(prior, repr_prior)
def test_set_maximum_setting(self):
for prior in self.priors:
- if isinstance(prior, (
- bilby.core.prior.DeltaFunction, bilby.core.prior.Gaussian,
- bilby.core.prior.HalfGaussian, bilby.core.prior.LogNormal,
- bilby.core.prior.Exponential, bilby.core.prior.StudentT,
- bilby.core.prior.Logistic, bilby.core.prior.Cauchy,
- bilby.core.prior.Gamma, bilby.core.prior.MultivariateGaussian,
- bilby.core.prior.FermiDirac, bilby.gw.prior.HealPixPrior)):
+ if isinstance(
+ prior,
+ (
+ bilby.core.prior.DeltaFunction,
+ bilby.core.prior.Gaussian,
+ bilby.core.prior.HalfGaussian,
+ bilby.core.prior.LogNormal,
+ bilby.core.prior.Exponential,
+ bilby.core.prior.StudentT,
+ bilby.core.prior.Logistic,
+ bilby.core.prior.Cauchy,
+ bilby.core.prior.Gamma,
+ bilby.core.prior.MultivariateGaussian,
+ bilby.core.prior.FermiDirac,
+ bilby.gw.prior.HealPixPrior,
+ ),
+ ):
continue
prior.maximum = (prior.maximum + prior.minimum) / 2
self.assertTrue(max(prior.sample(10000)) < prior.maximum)
def test_set_minimum_setting(self):
for prior in self.priors:
- if isinstance(prior, (
- bilby.core.prior.DeltaFunction, bilby.core.prior.Gaussian,
- bilby.core.prior.HalfGaussian, bilby.core.prior.LogNormal,
- bilby.core.prior.Exponential, bilby.core.prior.StudentT,
- bilby.core.prior.Logistic, bilby.core.prior.Cauchy,
- bilby.core.prior.Gamma, bilby.core.prior.MultivariateGaussian,
- bilby.core.prior.FermiDirac, bilby.gw.prior.HealPixPrior)):
+ if isinstance(
+ prior,
+ (
+ bilby.core.prior.DeltaFunction,
+ bilby.core.prior.Gaussian,
+ bilby.core.prior.HalfGaussian,
+ bilby.core.prior.LogNormal,
+ bilby.core.prior.Exponential,
+ bilby.core.prior.StudentT,
+ bilby.core.prior.Logistic,
+ bilby.core.prior.Cauchy,
+ bilby.core.prior.Gamma,
+ bilby.core.prior.MultivariateGaussian,
+ bilby.core.prior.FermiDirac,
+ bilby.gw.prior.HealPixPrior,
+ ),
+ ):
continue
prior.minimum = (prior.maximum + prior.minimum) / 2
self.assertTrue(min(prior.sample(10000)) > prior.minimum)
class TestPriorDict(unittest.TestCase):
-
def setUp(self):
- self.first_prior = bilby.core.prior.Uniform(name='a', minimum=0, maximum=1, unit='kg', boundary=None)
- self.second_prior = bilby.core.prior.PowerLaw(name='b', alpha=3, minimum=1, maximum=2, unit='m/s',
- boundary=None)
- self.third_prior = bilby.core.prior.DeltaFunction(name='c', peak=42, unit='m')
- self.priors = dict(mass=self.first_prior,
- speed=self.second_prior,
- length=self.third_prior)
+ self.first_prior = bilby.core.prior.Uniform(
+ name="a", minimum=0, maximum=1, unit="kg", boundary=None
+ )
+ self.second_prior = bilby.core.prior.PowerLaw(
+ name="b", alpha=3, minimum=1, maximum=2, unit="m/s", boundary=None
+ )
+ self.third_prior = bilby.core.prior.DeltaFunction(name="c", peak=42, unit="m")
+ self.priors = dict(
+ mass=self.first_prior, speed=self.second_prior, length=self.third_prior
+ )
self.prior_set_from_dict = bilby.core.prior.PriorDict(dictionary=self.priors)
- self.default_prior_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),
- 'prior_files/binary_black_holes.prior')
- self.prior_set_from_file = bilby.core.prior.PriorDict(filename=self.default_prior_file)
+ self.default_prior_file = os.path.join(
+ os.path.dirname(os.path.realpath(__file__)),
+ "prior_files/binary_black_holes.prior",
+ )
+ self.prior_set_from_file = bilby.core.prior.PriorDict(
+ filename=self.default_prior_file
+ )
def tearDown(self):
del self.first_prior
@@ -746,30 +947,59 @@ class TestPriorDict(unittest.TestCase):
def test_read_from_file(self):
expected = dict(
mass_1=bilby.core.prior.Uniform(
- name='mass_1', minimum=5, maximum=100, unit='$M_{\\odot}$', boundary=None),
+ name="mass_1",
+ minimum=5,
+ maximum=100,
+ unit="$M_{\\odot}$",
+ boundary=None,
+ ),
mass_2=bilby.core.prior.Uniform(
- name='mass_2', minimum=5, maximum=100, unit='$M_{\\odot}$', boundary=None),
- mass_ratio=bilby.core.prior.Constraint(name='mass_ratio', minimum=0.125, maximum=1, latex_label='$q$',
- unit=None),
- a_1=bilby.core.prior.Uniform(name='a_1', minimum=0, maximum=0.8, boundary='reflective'),
- a_2=bilby.core.prior.Uniform(name='a_2', minimum=0, maximum=0.8, boundary='reflective'),
- tilt_1=bilby.core.prior.Sine(name='tilt_1', boundary='reflective'),
- tilt_2=bilby.core.prior.Sine(name='tilt_2', boundary='reflective'),
+ name="mass_2",
+ minimum=5,
+ maximum=100,
+ unit="$M_{\\odot}$",
+ boundary=None,
+ ),
+ mass_ratio=bilby.core.prior.Constraint(
+ name="mass_ratio",
+ minimum=0.125,
+ maximum=1,
+ latex_label="$q$",
+ unit=None,
+ ),
+ a_1=bilby.core.prior.Uniform(
+ name="a_1", minimum=0, maximum=0.8, boundary="reflective"
+ ),
+ a_2=bilby.core.prior.Uniform(
+ name="a_2", minimum=0, maximum=0.8, boundary="reflective"
+ ),
+ tilt_1=bilby.core.prior.Sine(name="tilt_1", boundary="reflective"),
+ tilt_2=bilby.core.prior.Sine(name="tilt_2", boundary="reflective"),
phi_12=bilby.core.prior.Uniform(
- name='phi_12', minimum=0, maximum=2 * np.pi, boundary='periodic'),
+ name="phi_12", minimum=0, maximum=2 * np.pi, boundary="periodic"
+ ),
phi_jl=bilby.core.prior.Uniform(
- name='phi_jl', minimum=0, maximum=2 * np.pi, boundary='periodic'),
+ name="phi_jl", minimum=0, maximum=2 * np.pi, boundary="periodic"
+ ),
luminosity_distance=bilby.gw.prior.UniformSourceFrame(
- name='luminosity_distance', minimum=1e2,
- maximum=5e3, unit='Mpc', boundary=None),
- dec=bilby.core.prior.Cosine(name='dec', boundary='reflective'),
+ name="luminosity_distance",
+ minimum=1e2,
+ maximum=5e3,
+ unit="Mpc",
+ boundary=None,
+ ),
+ dec=bilby.core.prior.Cosine(name="dec", boundary="reflective"),
ra=bilby.core.prior.Uniform(
- name='ra', minimum=0, maximum=2 * np.pi, boundary='periodic'),
- theta_jn=bilby.core.prior.Sine(name='theta_jn', boundary='reflective'),
- psi=bilby.core.prior.Uniform(name='psi', minimum=0, maximum=np.pi, boundary='periodic'),
+ name="ra", minimum=0, maximum=2 * np.pi, boundary="periodic"
+ ),
+ theta_jn=bilby.core.prior.Sine(name="theta_jn", boundary="reflective"),
+ psi=bilby.core.prior.Uniform(
+ name="psi", minimum=0, maximum=np.pi, boundary="periodic"
+ ),
phase=bilby.core.prior.Uniform(
- name='phase', minimum=0, maximum=2 * np.pi, boundary='periodic')
- )
+ name="phase", minimum=0, maximum=2 * np.pi, boundary="periodic"
+ ),
+ )
self.assertDictEqual(expected, self.prior_set_from_file)
def test_to_file(self):
@@ -778,37 +1008,46 @@ class TestPriorDict(unittest.TestCase):
necessarily the same order as python2 doesn't conserve the order of the
arguments.
"""
- expected = ["length = DeltaFunction(peak=42, name='c', latex_label='c', unit='m')\n",
- "speed = PowerLaw(alpha=3, minimum=1, maximum=2, name='b', latex_label='b', "
- "unit='m/s', boundary=None)\n",
- "mass = Uniform(minimum=0, maximum=1, name='a', latex_label='a', "
- "unit='kg', boundary=None)\n"]
- self.prior_set_from_dict.to_file(outdir='prior_files', label='to_file_test')
- with open('prior_files/to_file_test.prior') as f:
+ expected = [
+ "length = DeltaFunction(peak=42, name='c', latex_label='c', unit='m')\n",
+ "speed = PowerLaw(alpha=3, minimum=1, maximum=2, name='b', latex_label='b', "
+ "unit='m/s', boundary=None)\n",
+ "mass = Uniform(minimum=0, maximum=1, name='a', latex_label='a', "
+ "unit='kg', boundary=None)\n",
+ ]
+ self.prior_set_from_dict.to_file(outdir="prior_files", label="to_file_test")
+ with open("prior_files/to_file_test.prior") as f:
for i, line in enumerate(f.readlines()):
- self.assertTrue(any([
- sorted(line) == sorted(expect) for expect in expected]))
+ self.assertTrue(
+ any([sorted(line) == sorted(expect) for expect in expected])
+ )
def test_from_dict_with_string(self):
- string_prior = "PowerLaw(name='b', alpha=3, minimum=1, maximum=2, unit='m/s', " \
- "boundary=None)"
- self.priors['speed'] = string_prior
+ string_prior = (
+ "PowerLaw(name='b', alpha=3, minimum=1, maximum=2, unit='m/s', "
+ "boundary=None)"
+ )
+ self.priors["speed"] = string_prior
from_dict = bilby.core.prior.PriorDict(dictionary=self.priors)
self.assertDictEqual(self.prior_set_from_dict, from_dict)
def test_convert_floats_to_delta_functions(self):
- self.prior_set_from_dict['d'] = 5
- self.prior_set_from_dict['e'] = 7.3
- self.prior_set_from_dict['f'] = 'unconvertable'
+ self.prior_set_from_dict["d"] = 5
+ self.prior_set_from_dict["e"] = 7.3
+ self.prior_set_from_dict["f"] = "unconvertable"
self.prior_set_from_dict.convert_floats_to_delta_functions()
- expected = dict(mass=bilby.core.prior.Uniform(name='a', minimum=0, maximum=1, unit='kg',
- boundary=None),
- speed=bilby.core.prior.PowerLaw(name='b', alpha=3, minimum=1, maximum=2, unit='m/s',
- boundary=None),
- length=bilby.core.prior.DeltaFunction(name='c', peak=42, unit='m'),
- d=bilby.core.prior.DeltaFunction(peak=5),
- e=bilby.core.prior.DeltaFunction(peak=7.3),
- f='unconvertable')
+ expected = dict(
+ mass=bilby.core.prior.Uniform(
+ name="a", minimum=0, maximum=1, unit="kg", boundary=None
+ ),
+ speed=bilby.core.prior.PowerLaw(
+ name="b", alpha=3, minimum=1, maximum=2, unit="m/s", boundary=None
+ ),
+ length=bilby.core.prior.DeltaFunction(name="c", peak=42, unit="m"),
+ d=bilby.core.prior.DeltaFunction(peak=5),
+ e=bilby.core.prior.DeltaFunction(peak=7.3),
+ f="unconvertable",
+ )
self.assertDictEqual(expected, self.prior_set_from_dict)
def test_prior_set_from_dict_but_using_a_string(self):
@@ -816,29 +1055,58 @@ class TestPriorDict(unittest.TestCase):
expected = bilby.core.prior.PriorDict(
dict(
mass_1=bilby.core.prior.Uniform(
- name='mass_1', minimum=5, maximum=100, unit='$M_{\\odot}$', boundary=None),
+ name="mass_1",
+ minimum=5,
+ maximum=100,
+ unit="$M_{\\odot}$",
+ boundary=None,
+ ),
mass_2=bilby.core.prior.Uniform(
- name='mass_2', minimum=5, maximum=100, unit='$M_{\\odot}$', boundary=None),
- mass_ratio=bilby.core.prior.Constraint(name='mass_ratio', minimum=0.125, maximum=1, latex_label='$q$',
- unit=None),
- a_1=bilby.core.prior.Uniform(name='a_1', minimum=0, maximum=0.8, boundary='reflective'),
- a_2=bilby.core.prior.Uniform(name='a_2', minimum=0, maximum=0.8, boundary='reflective'),
- tilt_1=bilby.core.prior.Sine(name='tilt_1', boundary='reflective'),
- tilt_2=bilby.core.prior.Sine(name='tilt_2', boundary='reflective'),
+ name="mass_2",
+ minimum=5,
+ maximum=100,
+ unit="$M_{\\odot}$",
+ boundary=None,
+ ),
+ mass_ratio=bilby.core.prior.Constraint(
+ name="mass_ratio",
+ minimum=0.125,
+ maximum=1,
+ latex_label="$q$",
+ unit=None,
+ ),
+ a_1=bilby.core.prior.Uniform(
+ name="a_1", minimum=0, maximum=0.8, boundary="reflective"
+ ),
+ a_2=bilby.core.prior.Uniform(
+ name="a_2", minimum=0, maximum=0.8, boundary="reflective"
+ ),
+ tilt_1=bilby.core.prior.Sine(name="tilt_1", boundary="reflective"),
+ tilt_2=bilby.core.prior.Sine(name="tilt_2", boundary="reflective"),
phi_12=bilby.core.prior.Uniform(
- name='phi_12', minimum=0, maximum=2 * np.pi, boundary='periodic'),
+ name="phi_12", minimum=0, maximum=2 * np.pi, boundary="periodic"
+ ),
phi_jl=bilby.core.prior.Uniform(
- name='phi_jl', minimum=0, maximum=2 * np.pi, boundary='periodic'),
+ name="phi_jl", minimum=0, maximum=2 * np.pi, boundary="periodic"
+ ),
luminosity_distance=bilby.gw.prior.UniformSourceFrame(
- name='luminosity_distance', minimum=1e2,
- maximum=5e3, unit='Mpc', boundary=None),
- dec=bilby.core.prior.Cosine(name='dec', boundary='reflective'),
+ name="luminosity_distance",
+ minimum=1e2,
+ maximum=5e3,
+ unit="Mpc",
+ boundary=None,
+ ),
+ dec=bilby.core.prior.Cosine(name="dec", boundary="reflective"),
ra=bilby.core.prior.Uniform(
- name='ra', minimum=0, maximum=2 * np.pi, boundary='periodic'),
- theta_jn=bilby.core.prior.Sine(name='theta_jn', boundary='reflective'),
- psi=bilby.core.prior.Uniform(name='psi', minimum=0, maximum=np.pi, boundary='periodic'),
+ name="ra", minimum=0, maximum=2 * np.pi, boundary="periodic"
+ ),
+ theta_jn=bilby.core.prior.Sine(name="theta_jn", boundary="reflective"),
+ psi=bilby.core.prior.Uniform(
+ name="psi", minimum=0, maximum=np.pi, boundary="periodic"
+ ),
phase=bilby.core.prior.Uniform(
- name='phase', minimum=0, maximum=2 * np.pi, boundary='periodic')
+ name="phase", minimum=0, maximum=2 * np.pi, boundary="periodic"
+ ),
)
)
all_keys = set(prior_set.keys()).union(set(expected.keys()))
@@ -851,21 +1119,25 @@ class TestPriorDict(unittest.TestCase):
def test_sample_subset_correct_size(self):
size = 7
- samples = self.prior_set_from_dict.sample_subset(keys=self.prior_set_from_dict.keys(), size=size)
+ samples = self.prior_set_from_dict.sample_subset(
+ keys=self.prior_set_from_dict.keys(), size=size
+ )
self.assertEqual(len(self.prior_set_from_dict), len(samples))
for key in samples:
self.assertEqual(size, len(samples[key]))
def test_sample_subset_correct_size_when_non_priors_in_dict(self):
- self.prior_set_from_dict['asdf'] = 'not_a_prior'
- samples = self.prior_set_from_dict.sample_subset(keys=self.prior_set_from_dict.keys())
+ self.prior_set_from_dict["asdf"] = "not_a_prior"
+ samples = self.prior_set_from_dict.sample_subset(
+ keys=self.prior_set_from_dict.keys()
+ )
self.assertEqual(len(self.prior_set_from_dict) - 1, len(samples))
def test_sample_subset_with_actual_subset(self):
size = 3
- samples = self.prior_set_from_dict.sample_subset(keys=['length'], size=size)
- expected = dict(length=np.array([42., 42., 42.]))
- self.assertTrue(np.array_equal(expected['length'], samples['length']))
+ samples = self.prior_set_from_dict.sample_subset(keys=["length"], size=size)
+ expected = dict(length=np.array([42.0, 42.0, 42.0]))
+ self.assertTrue(np.array_equal(expected["length"], samples["length"]))
def test_sample_subset_constrained_as_array(self):
size = 3
@@ -877,7 +1149,9 @@ class TestPriorDict(unittest.TestCase):
def test_sample(self):
size = 7
np.random.seed(42)
- samples1 = self.prior_set_from_dict.sample_subset(keys=self.prior_set_from_dict.keys(), size=size)
+ samples1 = self.prior_set_from_dict.sample_subset(
+ keys=self.prior_set_from_dict.keys(), size=size
+ )
np.random.seed(42)
samples2 = self.prior_set_from_dict.sample(size=size)
self.assertEqual(set(samples1.keys()), set(samples2.keys()))
@@ -885,22 +1159,34 @@ class TestPriorDict(unittest.TestCase):
self.assertTrue(np.array_equal(samples1[key], samples2[key]))
def test_prob(self):
- samples = self.prior_set_from_dict.sample_subset(keys=['mass', 'speed'])
- expected = self.first_prior.prob(samples['mass']) * self.second_prior.prob(samples['speed'])
+ samples = self.prior_set_from_dict.sample_subset(keys=["mass", "speed"])
+ expected = self.first_prior.prob(samples["mass"]) * self.second_prior.prob(
+ samples["speed"]
+ )
self.assertEqual(expected, self.prior_set_from_dict.prob(samples))
def test_ln_prob(self):
- samples = self.prior_set_from_dict.sample_subset(keys=['mass', 'speed'])
- expected = self.first_prior.ln_prob(samples['mass']) + self.second_prior.ln_prob(samples['speed'])
+ samples = self.prior_set_from_dict.sample_subset(keys=["mass", "speed"])
+ expected = self.first_prior.ln_prob(
+ samples["mass"]
+ ) + self.second_prior.ln_prob(samples["speed"])
self.assertEqual(expected, self.prior_set_from_dict.ln_prob(samples))
def test_rescale(self):
theta = [0.5, 0.5, 0.5]
- expected = [self.first_prior.rescale(0.5),
- self.second_prior.rescale(0.5),
- self.third_prior.rescale(0.5)]
- self.assertListEqual(sorted(expected), sorted(self.prior_set_from_dict.rescale(
- keys=self.prior_set_from_dict.keys(), theta=theta)))
+ expected = [
+ self.first_prior.rescale(0.5),
+ self.second_prior.rescale(0.5),
+ self.third_prior.rescale(0.5),
+ ]
+ self.assertListEqual(
+ sorted(expected),
+ sorted(
+ self.prior_set_from_dict.rescale(
+ keys=self.prior_set_from_dict.keys(), theta=theta
+ )
+ ),
+ )
def test_redundancy(self):
for key in self.prior_set_from_dict.keys():
@@ -909,50 +1195,61 @@ class TestPriorDict(unittest.TestCase):
class TestConstraintPriorNormalisation(unittest.TestCase):
def setUp(self):
- self.priors = dict(mass_1=bilby.core.prior.Uniform(name='mass_1', minimum=5, maximum=10, unit='$M_{\odot}$',
- boundary=None),
- mass_2=bilby.core.prior.Uniform(name='mass_2', minimum=5, maximum=10, unit='$M_{\odot}$',
- boundary=None),
- mass_ratio=bilby.core.prior.Constraint(name='mass_ratio', minimum=0, maximum=1))
+ self.priors = dict(
+ mass_1=bilby.core.prior.Uniform(
+ name="mass_1", minimum=5, maximum=10, unit="$M_{\odot}$", boundary=None
+ ),
+ mass_2=bilby.core.prior.Uniform(
+ name="mass_2", minimum=5, maximum=10, unit="$M_{\odot}$", boundary=None
+ ),
+ mass_ratio=bilby.core.prior.Constraint(
+ name="mass_ratio", minimum=0, maximum=1
+ ),
+ )
self.priors = bilby.core.prior.PriorDict(self.priors)
def test_prob_integrate_to_one(self):
- keys = ['mass_1', 'mass_2', 'mass_ratio']
+ keys = ["mass_1", "mass_2", "mass_ratio"]
n = 5000
samples = self.priors.sample_subset(keys=keys, size=n)
prob = self.priors.prob(samples, axis=0)
- dm1 = self.priors['mass_1'].maximum - self.priors['mass_1'].minimum
- dm2 = self.priors['mass_2'].maximum - self.priors['mass_2'].minimum
- integral = np.sum(prob * (dm1 * dm2)) / len(samples['mass_1'])
+ dm1 = self.priors["mass_1"].maximum - self.priors["mass_1"].minimum
+ dm2 = self.priors["mass_2"].maximum - self.priors["mass_2"].minimum
+ integral = np.sum(prob * (dm1 * dm2)) / len(samples["mass_1"])
self.assertAlmostEqual(1, integral, 5)
class TestLoadPrior(unittest.TestCase):
def test_load_prior_with_float(self):
- filename = os.path.join(os.path.dirname(os.path.realpath(__file__)),
- 'prior_files/prior_with_floats.prior')
+ filename = os.path.join(
+ os.path.dirname(os.path.realpath(__file__)),
+ "prior_files/prior_with_floats.prior",
+ )
prior = bilby.core.prior.PriorDict(filename)
self.assertTrue("mass_1" in prior)
self.assertTrue("mass_2" in prior)
- self.assertTrue(prior['mass_2'].peak == 20)
+ self.assertTrue(prior["mass_2"].peak == 20)
def test_load_prior_with_parentheses(self):
- filename = os.path.join(os.path.dirname(os.path.realpath(__file__)),
- 'prior_files/prior_with_parentheses.prior')
+ filename = os.path.join(
+ os.path.dirname(os.path.realpath(__file__)),
+ "prior_files/prior_with_parentheses.prior",
+ )
prior = bilby.core.prior.PriorDict(filename)
- self.assertTrue(isinstance(prior['logA'], bilby.core.prior.Uniform))
+ self.assertTrue(isinstance(prior["logA"], bilby.core.prior.Uniform))
class TestFillPrior(unittest.TestCase):
-
def setUp(self):
self.likelihood = Mock()
self.likelihood.parameters = dict(a=0, b=0, c=0, d=0, asdf=0, ra=1)
self.likelihood.non_standard_sampling_parameter_keys = dict(t=8)
self.priors = dict(a=1, b=1.1, c="string", d=bilby.core.prior.Uniform(0, 1))
self.priors = bilby.core.prior.PriorDict(dictionary=self.priors)
- self.default_prior_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),
- 'prior_files/binary_black_holes.prior')
+ self.default_prior_file = os.path.join(
+ os.path.dirname(os.path.realpath(__file__)),
+ "prior_files/binary_black_holes.prior",
+ )
self.priors.fill_priors(self.likelihood, self.default_prior_file)
def tearDown(self):
@@ -960,61 +1257,76 @@ class TestFillPrior(unittest.TestCase):
del self.priors
def test_prior_instances_are_not_changed_by_parsing(self):
- self.assertIsInstance(self.priors['d'], bilby.core.prior.Uniform)
+ self.assertIsInstance(self.priors["d"], bilby.core.prior.Uniform)
def test_parsing_ints_to_delta_priors_class(self):
- self.assertIsInstance(self.priors['a'], bilby.core.prior.DeltaFunction)
+ self.assertIsInstance(self.priors["a"], bilby.core.prior.DeltaFunction)
def test_parsing_ints_to_delta_priors_with_right_value(self):
- self.assertEqual(self.priors['a'].peak, 1)
+ self.assertEqual(self.priors["a"].peak, 1)
def test_parsing_floats_to_delta_priors_class(self):
- self.assertIsInstance(self.priors['b'], bilby.core.prior.DeltaFunction)
+ self.assertIsInstance(self.priors["b"], bilby.core.prior.DeltaFunction)
def test_parsing_floats_to_delta_priors_with_right_value(self):
- self.assertAlmostEqual(self.priors['b'].peak, 1.1, 1e-8)
+ self.assertAlmostEqual(self.priors["b"].peak, 1.1, 1e-8)
def test_without_available_default_priors_no_prior_is_set(self):
with self.assertRaises(KeyError):
- print(self.priors['asdf'])
+ print(self.priors["asdf"])
def test_with_available_default_priors_a_default_prior_is_set(self):
- self.assertIsInstance(self.priors['ra'], bilby.core.prior.Uniform)
+ self.assertIsInstance(self.priors["ra"], bilby.core.prior.Uniform)
class TestCreateDefaultPrior(unittest.TestCase):
-
def test_none_behaviour(self):
- self.assertIsNone(bilby.core.prior.create_default_prior(name='name', default_priors_file=None))
+ self.assertIsNone(
+ bilby.core.prior.create_default_prior(name="name", default_priors_file=None)
+ )
def test_bbh_params(self):
- prior_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'prior_files/binary_black_holes.prior')
+ prior_file = os.path.join(
+ os.path.dirname(os.path.realpath(__file__)),
+ "prior_files/binary_black_holes.prior",
+ )
prior_set = bilby.core.prior.PriorDict(filename=prior_file)
for prior in prior_set:
- self.assertEqual(prior_set[prior], bilby.core.prior.create_default_prior(name=prior,
- default_priors_file=prior_file))
+ self.assertEqual(
+ prior_set[prior],
+ bilby.core.prior.create_default_prior(
+ name=prior, default_priors_file=prior_file
+ ),
+ )
def test_unknown_prior(self):
- prior_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'prior_files/binary_black_holes.prior')
- self.assertIsNone(bilby.core.prior.create_default_prior(name='name', default_priors_file=prior_file))
+ prior_file = os.path.join(
+ os.path.dirname(os.path.realpath(__file__)),
+ "prior_files/binary_black_holes.prior",
+ )
+ self.assertIsNone(
+ bilby.core.prior.create_default_prior(
+ name="name", default_priors_file=prior_file
+ )
+ )
class TestConditionalPrior(unittest.TestCase):
-
def setUp(self):
self.condition_func_call_counter = 0
def condition_func(reference_parameters, test_variable_1, test_variable_2):
self.condition_func_call_counter += 1
return {key: value + 1 for key, value in reference_parameters.items()}
+
self.condition_func = condition_func
self.minimum = 0
self.maximum = 5
self.test_variable_1 = 0
self.test_variable_2 = 1
- self.prior = bilby.core.prior.ConditionalBasePrior(condition_func=condition_func,
- minimum=self.minimum,
- maximum=self.maximum)
+ self.prior = bilby.core.prior.ConditionalBasePrior(
+ condition_func=condition_func, minimum=self.minimum, maximum=self.maximum
+ )
def tearDown(self):
del self.condition_func
@@ -1026,34 +1338,51 @@ class TestConditionalPrior(unittest.TestCase):
del self.prior
def test_reference_params(self):
- self.assertDictEqual(dict(minimum=self.minimum, maximum=self.maximum), self.prior.reference_params)
+ self.assertDictEqual(
+ dict(minimum=self.minimum, maximum=self.maximum),
+ self.prior.reference_params,
+ )
def test_required_variables(self):
- self.assertListEqual(['test_variable_1', 'test_variable_2'], sorted(self.prior.required_variables))
+ self.assertListEqual(
+ ["test_variable_1", "test_variable_2"],
+ sorted(self.prior.required_variables),
+ )
def test_required_variables_no_condition_func(self):
- self.prior = bilby.core.prior.ConditionalBasePrior(condition_func=None,
- minimum=self.minimum,
- maximum=self.maximum)
+ self.prior = bilby.core.prior.ConditionalBasePrior(
+ condition_func=None, minimum=self.minimum, maximum=self.maximum
+ )
self.assertListEqual([], self.prior.required_variables)
def test_get_instantiation_dict(self):
- expected = dict(minimum=0, maximum=5, name=None, latex_label=None, unit=None,
- boundary=None, condition_func=self.condition_func)
+ expected = dict(
+ minimum=0,
+ maximum=5,
+ name=None,
+ latex_label=None,
+ unit=None,
+ boundary=None,
+ condition_func=self.condition_func,
+ )
actual = self.prior.get_instantiation_dict()
for key, value in expected.items():
- if key == 'condition_func':
+ if key == "condition_func":
continue
self.assertEqual(value, actual[key])
def test_update_conditions_correct_variables(self):
- self.prior.update_conditions(test_variable_1=self.test_variable_1, test_variable_2=self.test_variable_2)
+ self.prior.update_conditions(
+ test_variable_1=self.test_variable_1, test_variable_2=self.test_variable_2
+ )
self.assertEqual(1, self.condition_func_call_counter)
self.assertEqual(self.minimum + 1, self.prior.minimum)
self.assertEqual(self.maximum + 1, self.prior.maximum)
def test_update_conditions_no_variables(self):
- self.prior.update_conditions(test_variable_1=self.test_variable_1, test_variable_2=self.test_variable_2)
+ self.prior.update_conditions(
+ test_variable_1=self.test_variable_1, test_variable_2=self.test_variable_2
+ )
self.prior.update_conditions()
self.assertEqual(1, self.condition_func_call_counter)
self.assertEqual(self.minimum + 1, self.prior.minimum)
@@ -1064,49 +1393,72 @@ class TestConditionalPrior(unittest.TestCase):
self.prior.update_conditions(test_parameter_1=self.test_variable_1)
def test_sample_calls_update_conditions(self):
- with mock.patch.object(self.prior, 'update_conditions') as m:
- self.prior.sample(1,
- test_parameter_1=self.test_variable_1,
- test_parameter_2=self.test_variable_2)
- m.assert_called_with(test_parameter_1=self.test_variable_1, test_parameter_2=self.test_variable_2)
+ with mock.patch.object(self.prior, "update_conditions") as m:
+ self.prior.sample(
+ 1,
+ test_parameter_1=self.test_variable_1,
+ test_parameter_2=self.test_variable_2,
+ )
+ m.assert_called_with(
+ test_parameter_1=self.test_variable_1,
+ test_parameter_2=self.test_variable_2,
+ )
def test_rescale_calls_update_conditions(self):
- with mock.patch.object(self.prior, 'update_conditions') as m:
- self.prior.rescale(1, test_parameter_1=self.test_variable_1,
- test_parameter_2=self.test_variable_2)
- m.assert_called_with(test_parameter_1=self.test_variable_1,
- test_parameter_2=self.test_variable_2)
+ with mock.patch.object(self.prior, "update_conditions") as m:
+ self.prior.rescale(
+ 1,
+ test_parameter_1=self.test_variable_1,
+ test_parameter_2=self.test_variable_2,
+ )
+ m.assert_called_with(
+ test_parameter_1=self.test_variable_1,
+ test_parameter_2=self.test_variable_2,
+ )
def test_rescale_prob_update_conditions(self):
- with mock.patch.object(self.prior, 'update_conditions') as m:
- self.prior.prob(1, test_parameter_1=self.test_variable_1,
- test_parameter_2=self.test_variable_2)
- m.assert_called_with(test_parameter_1=self.test_variable_1,
- test_parameter_2=self.test_variable_2)
+ with mock.patch.object(self.prior, "update_conditions") as m:
+ self.prior.prob(
+ 1,
+ test_parameter_1=self.test_variable_1,
+ test_parameter_2=self.test_variable_2,
+ )
+ m.assert_called_with(
+ test_parameter_1=self.test_variable_1,
+ test_parameter_2=self.test_variable_2,
+ )
def test_rescale_ln_prob_update_conditions(self):
- with mock.patch.object(self.prior, 'update_conditions') as m:
- self.prior.ln_prob(1, test_parameter_1=self.test_variable_1,
- test_parameter_2=self.test_variable_2)
- calls = [mock.call(test_parameter_1=self.test_variable_1,
- test_parameter_2=self.test_variable_2),
- mock.call()]
+ with mock.patch.object(self.prior, "update_conditions") as m:
+ self.prior.ln_prob(
+ 1,
+ test_parameter_1=self.test_variable_1,
+ test_parameter_2=self.test_variable_2,
+ )
+ calls = [
+ mock.call(
+ test_parameter_1=self.test_variable_1,
+ test_parameter_2=self.test_variable_2,
+ ),
+ mock.call(),
+ ]
m.assert_has_calls(calls)
def test_reset_to_reference_parameters(self):
self.prior.minimum = 10
self.prior.maximum = 20
self.prior.reset_to_reference_parameters()
- self.assertEqual(self.prior.reference_params['minimum'], self.prior.minimum)
- self.assertEqual(self.prior.reference_params['maximum'], self.prior.maximum)
+ self.assertEqual(self.prior.reference_params["minimum"], self.prior.minimum)
+ self.assertEqual(self.prior.reference_params["maximum"], self.prior.maximum)
def test_cond_prior_instantiation_no_boundary_prior(self):
- prior = bilby.core.prior.ConditionalFermiDirac(condition_func=None, sigma=1, mu=1)
+ prior = bilby.core.prior.ConditionalFermiDirac(
+ condition_func=None, sigma=1, mu=1
+ )
self.assertIsNone(prior.boundary)
class TestConditionalPriorDict(unittest.TestCase):
-
def setUp(self):
def condition_func_1(reference_parameters, var_0):
return reference_parameters
@@ -1119,18 +1471,36 @@ class TestConditionalPriorDict(unittest.TestCase):
self.minimum = 0
self.maximum = 1
- self.prior_0 = bilby.core.prior.Uniform(minimum=self.minimum, maximum=self.maximum)
- self.prior_1 = bilby.core.prior.ConditionalUniform(condition_func=condition_func_1,
- minimum=self.minimum, maximum=self.maximum)
- self.prior_2 = bilby.core.prior.ConditionalUniform(condition_func=condition_func_2,
- minimum=self.minimum, maximum=self.maximum)
- self.prior_3 = bilby.core.prior.ConditionalUniform(condition_func=condition_func_3,
- minimum=self.minimum, maximum=self.maximum)
- self.conditional_priors = bilby.core.prior.ConditionalPriorDict(dict(var_3=self.prior_3, var_2=self.prior_2,
- var_0=self.prior_0, var_1=self.prior_1))
- self.conditional_priors_manually_set_items = bilby.core.prior.ConditionalPriorDict()
+ self.prior_0 = bilby.core.prior.Uniform(
+ minimum=self.minimum, maximum=self.maximum
+ )
+ self.prior_1 = bilby.core.prior.ConditionalUniform(
+ condition_func=condition_func_1, minimum=self.minimum, maximum=self.maximum
+ )
+ self.prior_2 = bilby.core.prior.ConditionalUniform(
+ condition_func=condition_func_2, minimum=self.minimum, maximum=self.maximum
+ )
+ self.prior_3 = bilby.core.prior.ConditionalUniform(
+ condition_func=condition_func_3, minimum=self.minimum, maximum=self.maximum
+ )
+ self.conditional_priors = bilby.core.prior.ConditionalPriorDict(
+ dict(
+ var_3=self.prior_3,
+ var_2=self.prior_2,
+ var_0=self.prior_0,
+ var_1=self.prior_1,
+ )
+ )
+ self.conditional_priors_manually_set_items = (
+ bilby.core.prior.ConditionalPriorDict()
+ )
self.test_sample = dict(var_0=0.3, var_1=0.4, var_2=0.5, var_3=0.4)
- for key, value in dict(var_0=self.prior_0, var_1=self.prior_1, var_2=self.prior_2, var_3=self.prior_3).items():
+ for key, value in dict(
+ var_0=self.prior_0,
+ var_1=self.prior_1,
+ var_2=self.prior_2,
+ var_3=self.prior_3,
+ ).items():
self.conditional_priors_manually_set_items[key] = value
def tearDown(self):
@@ -1145,29 +1515,40 @@ class TestConditionalPriorDict(unittest.TestCase):
del self.test_sample
def test_conditions_resolved_upon_instantiation(self):
- self.assertListEqual(['var_0', 'var_1', 'var_2', 'var_3'], self.conditional_priors.sorted_keys)
+ self.assertListEqual(
+ ["var_0", "var_1", "var_2", "var_3"], self.conditional_priors.sorted_keys
+ )
def test_conditions_resolved_setting_items(self):
- self.assertListEqual(['var_0', 'var_1', 'var_2', 'var_3'],
- self.conditional_priors_manually_set_items.sorted_keys)
+ self.assertListEqual(
+ ["var_0", "var_1", "var_2", "var_3"],
+ self.conditional_priors_manually_set_items.sorted_keys,
+ )
def test_unconditional_keys_upon_instantiation(self):
- self.assertListEqual(['var_0'], self.conditional_priors.unconditional_keys)
+ self.assertListEqual(["var_0"], self.conditional_priors.unconditional_keys)
def test_unconditional_keys_setting_items(self):
- self.assertListEqual(['var_0'], self.conditional_priors_manually_set_items.unconditional_keys)
+ self.assertListEqual(
+ ["var_0"], self.conditional_priors_manually_set_items.unconditional_keys
+ )
def test_conditional_keys_upon_instantiation(self):
- self.assertListEqual(['var_1', 'var_2', 'var_3'], self.conditional_priors.conditional_keys)
+ self.assertListEqual(
+ ["var_1", "var_2", "var_3"], self.conditional_priors.conditional_keys
+ )
def test_conditional_keys_setting_items(self):
- self.assertListEqual(['var_1', 'var_2', 'var_3'], self.conditional_priors_manually_set_items.conditional_keys)
+ self.assertListEqual(
+ ["var_1", "var_2", "var_3"],
+ self.conditional_priors_manually_set_items.conditional_keys,
+ )
def test_prob(self):
self.assertEqual(1, self.conditional_priors.prob(sample=self.test_sample))
def test_prob_illegal_conditions(self):
- del self.conditional_priors['var_0']
+ del self.conditional_priors["var_0"]
with self.assertRaises(bilby.core.prior.IllegalConditionsException):
self.conditional_priors.prob(sample=self.test_sample)
@@ -1175,156 +1556,238 @@ class TestConditionalPriorDict(unittest.TestCase):
self.assertEqual(0, self.conditional_priors.ln_prob(sample=self.test_sample))
def test_ln_prob_illegal_conditions(self):
- del self.conditional_priors['var_0']
+ del self.conditional_priors["var_0"]
with self.assertRaises(bilby.core.prior.IllegalConditionsException):
self.conditional_priors.ln_prob(sample=self.test_sample)
def test_sample_subset_all_keys(self):
with mock.patch("numpy.random.uniform") as m:
m.return_value = 0.5
- self.assertDictEqual(dict(var_0=0.5, var_1=0.5, var_2=0.5, var_3=0.5),
- self.conditional_priors.sample_subset(keys=['var_0', 'var_1', 'var_2', 'var_3']))
+ self.assertDictEqual(
+ dict(var_0=0.5, var_1=0.5, var_2=0.5, var_3=0.5),
+ self.conditional_priors.sample_subset(
+ keys=["var_0", "var_1", "var_2", "var_3"]
+ ),
+ )
def test_sample_illegal_subset(self):
with mock.patch("numpy.random.uniform") as m:
m.return_value = 0.5
with self.assertRaises(bilby.core.prior.IllegalConditionsException):
- self.conditional_priors.sample_subset(keys=['var_1'])
+ self.conditional_priors.sample_subset(keys=["var_1"])
def test_sample_multiple(self):
def condition_func(reference_params, a):
- return dict(minimum=reference_params['minimum'],
- maximum=reference_params['maximum'],
- alpha=reference_params['alpha'] * a)
+ return dict(
+ minimum=reference_params["minimum"],
+ maximum=reference_params["maximum"],
+ alpha=reference_params["alpha"] * a,
+ )
+
priors = bilby.core.prior.ConditionalPriorDict()
- priors['a'] = bilby.core.prior.Uniform(minimum=0, maximum=1)
- priors['b'] = bilby.core.prior.ConditionalPowerLaw(condition_func=condition_func, minimum=1, maximum=2,
- alpha=-2)
+ priors["a"] = bilby.core.prior.Uniform(minimum=0, maximum=1)
+ priors["b"] = bilby.core.prior.ConditionalPowerLaw(
+ condition_func=condition_func, minimum=1, maximum=2, alpha=-2
+ )
print(priors.sample(2))
def test_rescale(self):
-
def condition_func_1_rescale(reference_parameters, var_0):
if var_0 == 0.5:
- return dict(minimum=reference_parameters['minimum'], maximum=1)
+ return dict(minimum=reference_parameters["minimum"], maximum=1)
return reference_parameters
def condition_func_2_rescale(reference_parameters, var_0, var_1):
if var_0 == 0.5 and var_1 == 0.5:
- return dict(minimum=reference_parameters['minimum'], maximum=1)
+ return dict(minimum=reference_parameters["minimum"], maximum=1)
return reference_parameters
def condition_func_3_rescale(reference_parameters, var_1, var_2):
if var_1 == 0.5 and var_2 == 0.5:
- return dict(minimum=reference_parameters['minimum'], maximum=1)
+ return dict(minimum=reference_parameters["minimum"], maximum=1)
return reference_parameters
self.prior_0 = bilby.core.prior.Uniform(minimum=self.minimum, maximum=1)
- self.prior_1 = bilby.core.prior.ConditionalUniform(condition_func=condition_func_1_rescale,
- minimum=self.minimum, maximum=2)
- self.prior_2 = bilby.core.prior.ConditionalUniform(condition_func=condition_func_2_rescale,
- minimum=self.minimum, maximum=2)
- self.prior_3 = bilby.core.prior.ConditionalUniform(condition_func=condition_func_3_rescale,
- minimum=self.minimum, maximum=2)
- self.conditional_priors = bilby.core.prior.ConditionalPriorDict(dict(var_3=self.prior_3, var_2=self.prior_2,
- var_0=self.prior_0, var_1=self.prior_1))
+ self.prior_1 = bilby.core.prior.ConditionalUniform(
+ condition_func=condition_func_1_rescale, minimum=self.minimum, maximum=2
+ )
+ self.prior_2 = bilby.core.prior.ConditionalUniform(
+ condition_func=condition_func_2_rescale, minimum=self.minimum, maximum=2
+ )
+ self.prior_3 = bilby.core.prior.ConditionalUniform(
+ condition_func=condition_func_3_rescale, minimum=self.minimum, maximum=2
+ )
+ self.conditional_priors = bilby.core.prior.ConditionalPriorDict(
+ dict(
+ var_3=self.prior_3,
+ var_2=self.prior_2,
+ var_0=self.prior_0,
+ var_1=self.prior_1,
+ )
+ )
ref_variables = [0.5, 0.5, 0.5, 0.5]
- res = self.conditional_priors.rescale(keys=list(self.test_sample.keys()),
- theta=ref_variables)
+ res = self.conditional_priors.rescale(
+ keys=list(self.test_sample.keys()), theta=ref_variables
+ )
self.assertListEqual(ref_variables, res)
def test_rescale_illegal_conditions(self):
- del self.conditional_priors['var_0']
+ del self.conditional_priors["var_0"]
with self.assertRaises(bilby.core.prior.IllegalConditionsException):
- self.conditional_priors.rescale(keys=list(self.test_sample.keys()), theta=list(self.test_sample.values()))
+ self.conditional_priors.rescale(
+ keys=list(self.test_sample.keys()),
+ theta=list(self.test_sample.values()),
+ )
def test_combined_conditions(self):
def d_condition_func(reference_params, a, b, c):
- return dict(minimum=reference_params['minimum'], maximum=reference_params['maximum'])
+ return dict(
+ minimum=reference_params["minimum"], maximum=reference_params["maximum"]
+ )
def a_condition_func(reference_params, b, c):
- return dict(minimum=reference_params['minimum'], maximum=reference_params['maximum'])
+ return dict(
+ minimum=reference_params["minimum"], maximum=reference_params["maximum"]
+ )
priors = bilby.core.prior.ConditionalPriorDict()
- priors['a'] = bilby.core.prior.ConditionalUniform(condition_func=a_condition_func,
- minimum=0, maximum=1)
+ priors["a"] = bilby.core.prior.ConditionalUniform(
+ condition_func=a_condition_func, minimum=0, maximum=1
+ )
- priors['b'] = bilby.core.prior.LogUniform(minimum=1, maximum=10)
+ priors["b"] = bilby.core.prior.LogUniform(minimum=1, maximum=10)
- priors['d'] = bilby.core.prior.ConditionalUniform(condition_func=d_condition_func,
- minimum=0.0, maximum=1.0)
+ priors["d"] = bilby.core.prior.ConditionalUniform(
+ condition_func=d_condition_func, minimum=0.0, maximum=1.0
+ )
- priors['c'] = bilby.core.prior.LogUniform(minimum=1, maximum=10)
- sample = priors.sample()
- res = priors.rescale(['a', 'b', 'd', 'c'], [0.5, 0.5, 0.5, 0.5])
+ priors["c"] = bilby.core.prior.LogUniform(minimum=1, maximum=10)
+ priors.sample()
+ res = priors.rescale(["a", "b", "d", "c"], [0.5, 0.5, 0.5, 0.5])
print(res)
class TestJsonIO(unittest.TestCase):
-
def setUp(self):
- mvg = bilby.core.prior.MultivariateGaussianDist(names=['testa', 'testb'],
- mus=[1, 1],
- covs=np.array([[2., 0.5], [0.5, 2.]]),
- weights=1.)
- mvn = bilby.core.prior.MultivariateGaussianDist(names=['testa', 'testb'],
- mus=[1, 1],
- covs=np.array([[2., 0.5], [0.5, 2.]]),
- weights=1.)
- hp_map_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),
- 'prior_files/GW150914_testing_skymap.fits')
- hp_dist = bilby.gw.prior.HealPixMapPriorDist(hp_map_file,
- names=['testra', 'testdec'])
- hp_3d_dist = bilby.gw.prior.HealPixMapPriorDist(hp_map_file,
- names=['testra', 'testdec', 'testdistance'], distance=True)
-
- self.priors = bilby.core.prior.PriorDict(dict(
- a=bilby.core.prior.DeltaFunction(name='test', unit='unit', peak=1),
- b=bilby.core.prior.Gaussian(name='test', unit='unit', mu=0, sigma=1),
- c=bilby.core.prior.Normal(name='test', unit='unit', mu=0, sigma=1),
- d=bilby.core.prior.PowerLaw(name='test', unit='unit', alpha=0, minimum=0, maximum=1),
- e=bilby.core.prior.PowerLaw(name='test', unit='unit', alpha=-1, minimum=0.5, maximum=1),
- f=bilby.core.prior.PowerLaw(name='test', unit='unit', alpha=2, minimum=1, maximum=1e2),
- g=bilby.core.prior.Uniform(name='test', unit='unit', minimum=0, maximum=1),
- h=bilby.core.prior.LogUniform(name='test', unit='unit', minimum=5e0, maximum=1e2),
- i=bilby.gw.prior.UniformComovingVolume(name='redshift', minimum=0.1, maximum=1.0),
- j=bilby.gw.prior.UniformSourceFrame(name='luminosity_distance', minimum=1.0, maximum=1000.0),
- k=bilby.core.prior.Sine(name='test', unit='unit'),
- l=bilby.core.prior.Cosine(name='test', unit='unit'),
- m=bilby.core.prior.Interped(name='test', unit='unit', xx=np.linspace(0, 10, 1000),
- yy=np.linspace(0, 10, 1000) ** 4,
- minimum=3, maximum=5),
- n=bilby.core.prior.TruncatedGaussian(name='test', unit='unit', mu=1, sigma=0.4, minimum=-1, maximum=1),
- o=bilby.core.prior.TruncatedNormal(name='test', unit='unit', mu=1, sigma=0.4, minimum=-1, maximum=1),
- p=bilby.core.prior.HalfGaussian(name='test', unit='unit', sigma=1),
- q=bilby.core.prior.HalfNormal(name='test', unit='unit', sigma=1),
- r=bilby.core.prior.LogGaussian(name='test', unit='unit', mu=0, sigma=1),
- s=bilby.core.prior.LogNormal(name='test', unit='unit', mu=0, sigma=1),
- t=bilby.core.prior.Exponential(name='test', unit='unit', mu=1),
- u=bilby.core.prior.StudentT(name='test', unit='unit', df=3, mu=0, scale=1),
- v=bilby.core.prior.Beta(name='test', unit='unit', alpha=2.0, beta=2.0),
- x=bilby.core.prior.Logistic(name='test', unit='unit', mu=0, scale=1),
- y=bilby.core.prior.Cauchy(name='test', unit='unit', alpha=0, beta=1),
- z=bilby.core.prior.Lorentzian(name='test', unit='unit', alpha=0, beta=1),
- aa=bilby.core.prior.Gamma(name='test', unit='unit', k=1, theta=1),
- ab=bilby.core.prior.ChiSquared(name='test', unit='unit', nu=2),
- ac=bilby.gw.prior.AlignedSpin(name='test', unit='unit'),
- ad=bilby.core.prior.MultivariateGaussian(dist=mvg, name='testa', unit='unit'),
- ae=bilby.core.prior.MultivariateGaussian(dist=mvg, name='testb', unit='unit'),
- af=bilby.core.prior.MultivariateNormal(dist=mvn, name='testa', unit='unit'),
- ag=bilby.core.prior.MultivariateNormal(dist=mvn, name='testb', unit='unit'),
- ah=bilby.gw.prior.HealPixPrior(dist=hp_dist, name='testra', unit='unit'),
- ai=bilby.gw.prior.HealPixPrior(dist=hp_dist, name='testdec', unit='unit'),
- aj=bilby.gw.prior.HealPixPrior(dist=hp_3d_dist, name='testra', unit='unit'),
- ak=bilby.gw.prior.HealPixPrior(dist=hp_3d_dist, name='testdec', unit='unit'),
- al=bilby.gw.prior.HealPixPrior(dist=hp_3d_dist, name='testdistance', unit='unit')
- ))
+ mvg = bilby.core.prior.MultivariateGaussianDist(
+ names=["testa", "testb"],
+ mus=[1, 1],
+ covs=np.array([[2.0, 0.5], [0.5, 2.0]]),
+ weights=1.0,
+ )
+ mvn = bilby.core.prior.MultivariateGaussianDist(
+ names=["testa", "testb"],
+ mus=[1, 1],
+ covs=np.array([[2.0, 0.5], [0.5, 2.0]]),
+ weights=1.0,
+ )
+ hp_map_file = os.path.join(
+ os.path.dirname(os.path.realpath(__file__)),
+ "prior_files/GW150914_testing_skymap.fits",
+ )
+ hp_dist = bilby.gw.prior.HealPixMapPriorDist(
+ hp_map_file, names=["testra", "testdec"]
+ )
+ hp_3d_dist = bilby.gw.prior.HealPixMapPriorDist(
+ hp_map_file, names=["testra", "testdec", "testdistance"], distance=True
+ )
+
+ self.priors = bilby.core.prior.PriorDict(
+ dict(
+ aa=bilby.core.prior.DeltaFunction(name="test", unit="unit", peak=1),
+ bb=bilby.core.prior.Gaussian(name="test", unit="unit", mu=0, sigma=1),
+ cc=bilby.core.prior.Normal(name="test", unit="unit", mu=0, sigma=1),
+ dd=bilby.core.prior.PowerLaw(
+ name="test", unit="unit", alpha=0, minimum=0, maximum=1
+ ),
+ ee=bilby.core.prior.PowerLaw(
+ name="test", unit="unit", alpha=-1, minimum=0.5, maximum=1
+ ),
+ ff=bilby.core.prior.PowerLaw(
+ name="test", unit="unit", alpha=2, minimum=1, maximum=1e2
+ ),
+ gg=bilby.core.prior.Uniform(
+ name="test", unit="unit", minimum=0, maximum=1
+ ),
+ hh=bilby.core.prior.LogUniform(
+ name="test", unit="unit", minimum=5e0, maximum=1e2
+ ),
+ ii=bilby.gw.prior.UniformComovingVolume(
+ name="redshift", minimum=0.1, maximum=1.0
+ ),
+ jj=bilby.gw.prior.UniformSourceFrame(
+ name="luminosity_distance", minimum=1.0, maximum=1000.0
+ ),
+ kk=bilby.core.prior.Sine(name="test", unit="unit"),
+ ll=bilby.core.prior.Cosine(name="test", unit="unit"),
+ m=bilby.core.prior.Interped(
+ name="test",
+ unit="unit",
+ xx=np.linspace(0, 10, 1000),
+ yy=np.linspace(0, 10, 1000) ** 4,
+ minimum=3,
+ maximum=5,
+ ),
+ nn=bilby.core.prior.TruncatedGaussian(
+ name="test", unit="unit", mu=1, sigma=0.4, minimum=-1, maximum=1
+ ),
+ oo=bilby.core.prior.TruncatedNormal(
+ name="test", unit="unit", mu=1, sigma=0.4, minimum=-1, maximum=1
+ ),
+ pp=bilby.core.prior.HalfGaussian(name="test", unit="unit", sigma=1),
+ qq=bilby.core.prior.HalfNormal(name="test", unit="unit", sigma=1),
+ rr=bilby.core.prior.LogGaussian(name="test", unit="unit", mu=0, sigma=1),
+ ss=bilby.core.prior.LogNormal(name="test", unit="unit", mu=0, sigma=1),
+ tt=bilby.core.prior.Exponential(name="test", unit="unit", mu=1),
+ uu=bilby.core.prior.StudentT(
+ name="test", unit="unit", df=3, mu=0, scale=1
+ ),
+ vv=bilby.core.prior.Beta(name="test", unit="unit", alpha=2.0, beta=2.0),
+ xx=bilby.core.prior.Logistic(name="test", unit="unit", mu=0, scale=1),
+ yy=bilby.core.prior.Cauchy(name="test", unit="unit", alpha=0, beta=1),
+ zz=bilby.core.prior.Lorentzian(
+ name="test", unit="unit", alpha=0, beta=1
+ ),
+ a_=bilby.core.prior.Gamma(name="test", unit="unit", k=1, theta=1),
+ ab=bilby.core.prior.ChiSquared(name="test", unit="unit", nu=2),
+ ac=bilby.gw.prior.AlignedSpin(name="test", unit="unit"),
+ ad=bilby.core.prior.MultivariateGaussian(
+ dist=mvg, name="testa", unit="unit"
+ ),
+ ae=bilby.core.prior.MultivariateGaussian(
+ dist=mvg, name="testb", unit="unit"
+ ),
+ af=bilby.core.prior.MultivariateNormal(
+ dist=mvn, name="testa", unit="unit"
+ ),
+ ag=bilby.core.prior.MultivariateNormal(
+ dist=mvn, name="testb", unit="unit"
+ ),
+ ah=bilby.gw.prior.HealPixPrior(
+ dist=hp_dist, name="testra", unit="unit"
+ ),
+ ai=bilby.gw.prior.HealPixPrior(
+ dist=hp_dist, name="testdec", unit="unit"
+ ),
+ aj=bilby.gw.prior.HealPixPrior(
+ dist=hp_3d_dist, name="testra", unit="unit"
+ ),
+ ak=bilby.gw.prior.HealPixPrior(
+ dist=hp_3d_dist, name="testdec", unit="unit"
+ ),
+ al=bilby.gw.prior.HealPixPrior(
+ dist=hp_3d_dist, name="testdistance", unit="unit"
+ ),
+ )
+ )
def test_read_write_to_json(self):
""" Interped prior is removed as there is numerical error in the recovered prior."""
self.priors.to_json(outdir="prior_files", label="json_test")
- new_priors = bilby.core.prior.PriorDict.from_json(filename="prior_files/json_test_prior.json")
+ new_priors = bilby.core.prior.PriorDict.from_json(
+ filename="prior_files/json_test_prior.json"
+ )
old_interped = self.priors.pop("m")
new_interped = new_priors.pop("m")
self.assertDictEqual(self.priors, new_priors)
@@ -1332,5 +1795,5 @@ class TestJsonIO(unittest.TestCase):
self.assertLess(max(abs(old_interped.yy - new_interped.yy)), 1e-15)
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/proposal_test.py b/test/proposal_test.py
index 798f78d69b57515f00e2272c8b903ed6ee4e80d8..8af0df18511ff6d3b3d46c3da7d441f95468607b 100644
--- a/test/proposal_test.py
+++ b/test/proposal_test.py
@@ -10,7 +10,6 @@ from bilby.core.sampler import proposal
class TestSample(unittest.TestCase):
-
def setUp(self):
self.sample = proposal.Sample(dict(a=1, c=2))
@@ -34,17 +33,28 @@ class TestSample(unittest.TestCase):
class TestJumpProposal(unittest.TestCase):
-
def setUp(self):
- self.priors = prior.PriorDict(dict(reflective=prior.Uniform(minimum=-0.5, maximum=1, boundary='reflective'),
- periodic=prior.Uniform(minimum=-0.5, maximum=1, boundary='periodic'),
- default=prior.Uniform(minimum=-0.5, maximum=1)))
+ self.priors = prior.PriorDict(
+ dict(
+ reflective=prior.Uniform(
+ minimum=-0.5, maximum=1, boundary="reflective"
+ ),
+ periodic=prior.Uniform(minimum=-0.5, maximum=1, boundary="periodic"),
+ default=prior.Uniform(minimum=-0.5, maximum=1),
+ )
+ )
self.sample_above = dict(reflective=1.1, periodic=1.1, default=1.1)
self.sample_below = dict(reflective=-0.6, periodic=-0.6, default=-0.6)
self.sample_way_above_case1 = dict(reflective=272, periodic=272, default=272)
- self.sample_way_above_case2 = dict(reflective=270.1, periodic=270.1, default=270.1)
- self.sample_way_below_case1 = dict(reflective=-274, periodic=-274.1, default=-274)
- self.sample_way_below_case2 = dict(reflective=-273.1, periodic=-273.1, default=-273.1)
+ self.sample_way_above_case2 = dict(
+ reflective=270.1, periodic=270.1, default=270.1
+ )
+ self.sample_way_below_case1 = dict(
+ reflective=-274, periodic=-274.1, default=-274
+ )
+ self.sample_way_below_case2 = dict(
+ reflective=-273.1, periodic=-273.1, default=-273.1
+ )
self.jump_proposal = proposal.JumpProposal(priors=self.priors)
def tearDown(self):
@@ -63,62 +73,65 @@ class TestJumpProposal(unittest.TestCase):
def test_boundary_above_reflective(self):
new_sample = self.jump_proposal(self.sample_above)
- self.assertAlmostEqual(0.9, new_sample['reflective'])
+ self.assertAlmostEqual(0.9, new_sample["reflective"])
def test_boundary_above_periodic(self):
new_sample = self.jump_proposal(self.sample_above)
- self.assertAlmostEqual(-0.4, new_sample['periodic'])
+ self.assertAlmostEqual(-0.4, new_sample["periodic"])
def test_boundary_above_default(self):
new_sample = self.jump_proposal(self.sample_above)
- self.assertAlmostEqual(1.1, new_sample['default'])
+ self.assertAlmostEqual(1.1, new_sample["default"])
def test_boundary_below_reflective(self):
new_sample = self.jump_proposal(self.sample_below)
- self.assertAlmostEqual(-0.4, new_sample['reflective'])
+ self.assertAlmostEqual(-0.4, new_sample["reflective"])
def test_boundary_below_periodic(self):
new_sample = self.jump_proposal(self.sample_below)
- self.assertAlmostEqual(0.9, new_sample['periodic'])
+ self.assertAlmostEqual(0.9, new_sample["periodic"])
def test_boundary_below_default(self):
new_sample = self.jump_proposal(self.sample_below)
- self.assertAlmostEqual(-0.6, new_sample['default'])
+ self.assertAlmostEqual(-0.6, new_sample["default"])
def test_boundary_way_below_reflective_case1(self):
new_sample = self.jump_proposal(self.sample_way_below_case1)
- self.assertAlmostEqual(0.0, new_sample['reflective'])
+ self.assertAlmostEqual(0.0, new_sample["reflective"])
def test_boundary_way_below_reflective_case2(self):
new_sample = self.jump_proposal(self.sample_way_below_case2)
- self.assertAlmostEqual(-0.1, new_sample['reflective'])
+ self.assertAlmostEqual(-0.1, new_sample["reflective"])
def test_boundary_way_below_periodic(self):
new_sample = self.jump_proposal(self.sample_way_below_case2)
- self.assertAlmostEqual(-0.1, new_sample['periodic'])
+ self.assertAlmostEqual(-0.1, new_sample["periodic"])
def test_boundary_way_above_reflective_case1(self):
new_sample = self.jump_proposal(self.sample_way_above_case1)
- self.assertAlmostEqual(0.0, new_sample['reflective'])
+ self.assertAlmostEqual(0.0, new_sample["reflective"])
def test_boundary_way_above_reflective_case2(self):
new_sample = self.jump_proposal(self.sample_way_above_case2)
- self.assertAlmostEqual(0.1, new_sample['reflective'])
+ self.assertAlmostEqual(0.1, new_sample["reflective"])
def test_boundary_way_above_periodic(self):
new_sample = self.jump_proposal(self.sample_way_above_case2)
- self.assertAlmostEqual(0.1, new_sample['periodic'])
+ self.assertAlmostEqual(0.1, new_sample["periodic"])
def test_priors(self):
self.assertEqual(self.priors, self.jump_proposal.priors)
class TestNormJump(unittest.TestCase):
-
def setUp(self):
- self.priors = prior.PriorDict(dict(reflective=prior.Uniform(minimum=-0.5, maximum=1, boundary='periodic'),
- periodic=prior.Uniform(minimum=-0.5, maximum=1, boundary='reflective'),
- default=prior.Uniform(minimum=-0.5, maximum=1)))
+ self.priors = prior.PriorDict(
+ dict(
+ reflective=prior.Uniform(minimum=-0.5, maximum=1, boundary="periodic"),
+ periodic=prior.Uniform(minimum=-0.5, maximum=1, boundary="reflective"),
+ default=prior.Uniform(minimum=-0.5, maximum=1),
+ )
+ )
self.jump_proposal = proposal.NormJump(step_size=3.0, priors=self.priors)
def tearDown(self):
@@ -142,13 +155,19 @@ class TestNormJump(unittest.TestCase):
class TestEnsembleWalk(unittest.TestCase):
-
def setUp(self):
- self.priors = prior.PriorDict(dict(reflective=prior.Uniform(minimum=-0.5, maximum=1, boundary='reflective'),
- periodic=prior.Uniform(minimum=-0.5, maximum=1, boundary='periodic'),
- default=prior.Uniform(minimum=-0.5, maximum=1)))
- self.jump_proposal = proposal.EnsembleWalk(random_number_generator=random.random,
- n_points=4, priors=self.priors)
+ self.priors = prior.PriorDict(
+ dict(
+ reflective=prior.Uniform(
+ minimum=-0.5, maximum=1, boundary="reflective"
+ ),
+ periodic=prior.Uniform(minimum=-0.5, maximum=1, boundary="periodic"),
+ default=prior.Uniform(minimum=-0.5, maximum=1),
+ )
+ )
+ self.jump_proposal = proposal.EnsembleWalk(
+ random_number_generator=random.random, n_points=4, priors=self.priors
+ )
def tearDown(self):
del self.priors
@@ -165,17 +184,22 @@ class TestEnsembleWalk(unittest.TestCase):
self.assertEqual(random.random, self.jump_proposal.random_number_generator)
def test_get_center_of_mass(self):
- samples = [proposal.Sample(dict(reflective=0.1*i, periodic=0.1*i, default=0.1*i)) for i in range(3)]
+ samples = [
+ proposal.Sample(dict(reflective=0.1 * i, periodic=0.1 * i, default=0.1 * i))
+ for i in range(3)
+ ]
expected = proposal.Sample(dict(reflective=0.1, periodic=0.1, default=0.1))
actual = self.jump_proposal.get_center_of_mass(samples)
for key in samples[0].keys():
self.assertAlmostEqual(expected[key], actual[key])
def test_jump_proposal_call(self):
- with mock.patch('random.sample') as m:
+ with mock.patch("random.sample") as m:
self.jump_proposal.random_number_generator = lambda: 2
- m.return_value = [proposal.Sample(dict(periodic=0.3, reflective=0.3, default=0.3)),
- proposal.Sample(dict(periodic=0.1, reflective=0.1, default=0.1))]
+ m.return_value = [
+ proposal.Sample(dict(periodic=0.3, reflective=0.3, default=0.3)),
+ proposal.Sample(dict(periodic=0.1, reflective=0.1, default=0.1)),
+ ]
sample = proposal.Sample(dict(periodic=0.1, reflective=0.1, default=0.1))
new_sample = self.jump_proposal(sample, coordinates=None)
expected = proposal.Sample(dict(periodic=0.1, reflective=0.1, default=0.1))
@@ -184,11 +208,16 @@ class TestEnsembleWalk(unittest.TestCase):
class TestEnsembleEnsembleStretch(unittest.TestCase):
-
def setUp(self):
- self.priors = prior.PriorDict(dict(reflective=prior.Uniform(minimum=-0.5, maximum=1, boundary='reflective'),
- periodic=prior.Uniform(minimum=-0.5, maximum=1, boundary='periodic'),
- default=prior.Uniform(minimum=-0.5, maximum=1)))
+ self.priors = prior.PriorDict(
+ dict(
+ reflective=prior.Uniform(
+ minimum=-0.5, maximum=1, boundary="reflective"
+ ),
+ periodic=prior.Uniform(minimum=-0.5, maximum=1, boundary="periodic"),
+ default=prior.Uniform(minimum=-0.5, maximum=1),
+ )
+ )
self.jump_proposal = proposal.EnsembleStretch(scale=3.0, priors=self.priors)
def tearDown(self):
@@ -203,41 +232,63 @@ class TestEnsembleEnsembleStretch(unittest.TestCase):
self.assertEqual(5.0, self.jump_proposal.scale)
def test_jump_proposal_call(self):
- with mock.patch('random.choice') as m:
- with mock.patch('random.uniform') as n:
- second_sample = proposal.Sample(dict(periodic=0.3, reflective=0.3, default=0.3))
+ with mock.patch("random.choice") as m:
+ with mock.patch("random.uniform") as n:
+ second_sample = proposal.Sample(
+ dict(periodic=0.3, reflective=0.3, default=0.3)
+ )
random_number = 0.5
m.return_value = second_sample
n.return_value = random_number
- sample = proposal.Sample(dict(periodic=0.1, reflective=0.1, default=0.1))
+ sample = proposal.Sample(
+ dict(periodic=0.1, reflective=0.1, default=0.1)
+ )
new_sample = self.jump_proposal(sample, coordinates=None)
- coords = 0.3 - 0.2 * np.exp(random_number * np.log(self.jump_proposal.scale))
- expected = proposal.Sample(dict(periodic=coords, reflective=coords, default=coords))
+ coords = 0.3 - 0.2 * np.exp(
+ random_number * np.log(self.jump_proposal.scale)
+ )
+ expected = proposal.Sample(
+ dict(periodic=coords, reflective=coords, default=coords)
+ )
for key, value in new_sample.items():
self.assertAlmostEqual(expected[key], value)
def test_log_j_after_call(self):
- with mock.patch('random.uniform') as m1:
- with mock.patch('numpy.log') as m2:
- with mock.patch('numpy.exp') as m3:
+ with mock.patch("random.uniform") as m1:
+ with mock.patch("numpy.log") as m2:
+ with mock.patch("numpy.exp") as m3:
m1.return_value = 1
m2.return_value = 1
m3.return_value = 1
- coordinates = [proposal.Sample(dict(periodic=0.3, reflective=0.3, default=0.3)),
- proposal.Sample(dict(periodic=0.3, reflective=0.3, default=0.3))]
- sample = proposal.Sample(dict(periodic=0.2, reflective=0.2, default=0.2))
- self.jump_proposal(sample=sample,
- coordinates=coordinates)
+ coordinates = [
+ proposal.Sample(
+ dict(periodic=0.3, reflective=0.3, default=0.3)
+ ),
+ proposal.Sample(
+ dict(periodic=0.3, reflective=0.3, default=0.3)
+ ),
+ ]
+ sample = proposal.Sample(
+ dict(periodic=0.2, reflective=0.2, default=0.2)
+ )
+ self.jump_proposal(sample=sample, coordinates=coordinates)
self.assertEqual(3, self.jump_proposal.log_j)
class TestDifferentialEvolution(unittest.TestCase):
-
def setUp(self):
- self.priors = prior.PriorDict(dict(reflective=prior.Uniform(minimum=-0.5, maximum=1, boundary='reflective'),
- periodic=prior.Uniform(minimum=-0.5, maximum=1, boundary='periodic'),
- default=prior.Uniform(minimum=-0.5, maximum=1)))
- self.jump_proposal = proposal.DifferentialEvolution(sigma=1e-3, mu=0.5, priors=self.priors)
+ self.priors = prior.PriorDict(
+ dict(
+ reflective=prior.Uniform(
+ minimum=-0.5, maximum=1, boundary="reflective"
+ ),
+ periodic=prior.Uniform(minimum=-0.5, maximum=1, boundary="periodic"),
+ default=prior.Uniform(minimum=-0.5, maximum=1),
+ )
+ )
+ self.jump_proposal = proposal.DifferentialEvolution(
+ sigma=1e-3, mu=0.5, priors=self.priors
+ )
def tearDown(self):
del self.priors
@@ -255,24 +306,35 @@ class TestDifferentialEvolution(unittest.TestCase):
self.assertEqual(2, self.jump_proposal.sigma)
def test_jump_proposal_call(self):
- with mock.patch('random.sample') as m:
- with mock.patch('random.gauss') as n:
- m.return_value = proposal.Sample(dict(periodic=0.2, reflective=0.2, default=0.2)),\
- proposal.Sample(dict(periodic=0.3, reflective=0.3, default=0.3))
+ with mock.patch("random.sample") as m:
+ with mock.patch("random.gauss") as n:
+ m.return_value = (
+ proposal.Sample(dict(periodic=0.2, reflective=0.2, default=0.2)),
+ proposal.Sample(dict(periodic=0.3, reflective=0.3, default=0.3)),
+ )
n.return_value = 1
- sample = proposal.Sample(dict(periodic=0.1, reflective=0.1, default=0.1))
- expected = proposal.Sample(dict(periodic=0.2, reflective=0.2, default=0.2))
+ sample = proposal.Sample(
+ dict(periodic=0.1, reflective=0.1, default=0.1)
+ )
+ expected = proposal.Sample(
+ dict(periodic=0.2, reflective=0.2, default=0.2)
+ )
new_sample = self.jump_proposal(sample, coordinates=None)
for key, value in new_sample.items():
self.assertAlmostEqual(expected[key], value)
class TestEnsembleEigenVector(unittest.TestCase):
-
def setUp(self):
- self.priors = prior.PriorDict(dict(reflective=prior.Uniform(minimum=-0.5, maximum=1, boundary='reflective'),
- periodic=prior.Uniform(minimum=-0.5, maximum=1, boundary='periodic'),
- default=prior.Uniform(minimum=-0.5, maximum=1)))
+ self.priors = prior.PriorDict(
+ dict(
+ reflective=prior.Uniform(
+ minimum=-0.5, maximum=1, boundary="reflective"
+ ),
+ periodic=prior.Uniform(minimum=-0.5, maximum=1, boundary="periodic"),
+ default=prior.Uniform(minimum=-0.5, maximum=1),
+ )
+ )
self.jump_proposal = proposal.EnsembleEigenVector(priors=self.priors)
def tearDown(self):
@@ -292,62 +354,79 @@ class TestEnsembleEigenVector(unittest.TestCase):
self.assertIsNone(self.jump_proposal.update_eigenvectors(coordinates=None))
def test_jump_proposal_update_eigenvectors_1_d(self):
- coordinates = [proposal.Sample(dict(periodic=0.3)), proposal.Sample(dict(periodic=0.1))]
- with mock.patch('numpy.var') as m:
+ coordinates = [
+ proposal.Sample(dict(periodic=0.3)),
+ proposal.Sample(dict(periodic=0.1)),
+ ]
+ with mock.patch("numpy.var") as m:
m.return_value = 1
self.jump_proposal.update_eigenvectors(coordinates)
self.assertTrue(np.equal(np.array([1]), self.jump_proposal.eigen_values))
self.assertTrue(np.equal(np.array([1]), self.jump_proposal.covariance))
- self.assertTrue(np.equal(np.array([[1.]]), self.jump_proposal.eigen_vectors))
+ self.assertTrue(
+ np.equal(np.array([[1.0]]), self.jump_proposal.eigen_vectors)
+ )
def test_jump_proposal_update_eigenvectors_n_d(self):
- coordinates = [proposal.Sample(dict(periodic=0.3, reflective=0.3, default=0.3)),
- proposal.Sample(dict(periodic=0.1, reflective=0.1, default=0.1))]
- with mock.patch('numpy.cov') as m:
- with mock.patch('numpy.linalg.eigh') as n:
+ coordinates = [
+ proposal.Sample(dict(periodic=0.3, reflective=0.3, default=0.3)),
+ proposal.Sample(dict(periodic=0.1, reflective=0.1, default=0.1)),
+ ]
+ with mock.patch("numpy.cov") as m:
+ with mock.patch("numpy.linalg.eigh") as n:
m.side_effect = lambda x: x
n.return_value = 1, 2
self.jump_proposal.update_eigenvectors(coordinates)
- self.assertTrue(np.array_equal(np.array([[0.3, 0.1], [0.3, 0.1], [0.3, 0.1]]), self.jump_proposal.covariance))
+ self.assertTrue(
+ np.array_equal(
+ np.array([[0.3, 0.1], [0.3, 0.1], [0.3, 0.1]]),
+ self.jump_proposal.covariance,
+ )
+ )
self.assertEqual(1, self.jump_proposal.eigen_values)
self.assertEqual(2, self.jump_proposal.eigen_vectors)
def test_jump_proposal_call(self):
self.jump_proposal.update_eigenvectors = lambda x: None
self.jump_proposal.eigen_values = np.array([1, np.nan, np.nan])
- self.jump_proposal.eigen_vectors = np.array([[0.1, np.nan, np.nan],
- [0.4, np.nan, np.nan],
- [0.7, np.nan, np.nan]])
- with mock.patch('random.randrange') as m:
- with mock.patch('random.gauss') as n:
+ self.jump_proposal.eigen_vectors = np.array(
+ [[0.1, np.nan, np.nan], [0.4, np.nan, np.nan], [0.7, np.nan, np.nan]]
+ )
+ with mock.patch("random.randrange") as m:
+ with mock.patch("random.gauss") as n:
m.return_value = 0
n.return_value = 1
expected = proposal.Sample()
- expected['periodic'] = 0.2
- expected['reflective'] = 0.5
- expected['default'] = 0.8
+ expected["periodic"] = 0.2
+ expected["reflective"] = 0.5
+ expected["default"] = 0.8
sample = proposal.Sample()
- sample['periodic'] = 0.1
- sample['reflective'] = 0.1
- sample['default'] = 0.1
+ sample["periodic"] = 0.1
+ sample["reflective"] = 0.1
+ sample["default"] = 0.1
new_sample = self.jump_proposal(sample, coordinates=None)
for key, value in new_sample.items():
self.assertAlmostEqual(expected[key], value)
class TestSkyLocationWanderJump(unittest.TestCase):
-
def setUp(self):
- self.priors = prior.PriorDict(dict(ra=prior.Uniform(minimum=0.0, maximum=2*np.pi, boundary='periodic'),
- dec=prior.Uniform(minimum=0.0, maximum=np.pi, boundary='reflective')))
- self.jump_proposal = bilby.gw.sampler.proposal.SkyLocationWanderJump(priors=self.priors)
+ self.priors = prior.PriorDict(
+ dict(
+ ra=prior.Uniform(minimum=0.0, maximum=2 * np.pi, boundary="periodic"),
+ dec=prior.Uniform(minimum=0.0, maximum=np.pi, boundary="reflective"),
+ )
+ )
+ self.jump_proposal = bilby.gw.sampler.proposal.SkyLocationWanderJump(
+ priors=self.priors
+ )
def tearDown(self):
del self.priors
del self.jump_proposal
def test_jump_proposal_call_without_inverse_temperature(self):
- with mock.patch('random.gauss') as m:
+ with mock.patch("random.gauss") as m:
m.return_value = 1
sample = proposal.Sample(dict(ra=0.2, dec=-0.5))
expected = proposal.Sample(dict(ra=1.2, dec=0.5))
@@ -357,7 +436,7 @@ class TestSkyLocationWanderJump(unittest.TestCase):
m.assert_called_with(0, 1.0 / 2 / np.pi)
def test_jump_proposal_call_with_inverse_temperature(self):
- with mock.patch('random.gauss') as m:
+ with mock.patch("random.gauss") as m:
m.return_value = 1
sample = proposal.Sample(dict(ra=0.2, dec=-0.5))
expected = proposal.Sample(dict(ra=1.2, dec=0.5))
@@ -368,41 +447,55 @@ class TestSkyLocationWanderJump(unittest.TestCase):
class TestCorrelatedPolarisationPhaseJump(unittest.TestCase):
-
def setUp(self):
- self.priors = prior.PriorDict(dict(phase=prior.Uniform(minimum=0.0, maximum=2*np.pi),
- psi=prior.Uniform(minimum=0.0, maximum=np.pi)))
- self.jump_proposal = bilby.gw.sampler.proposal.CorrelatedPolarisationPhaseJump(priors=self.priors)
+ self.priors = prior.PriorDict(
+ dict(
+ phase=prior.Uniform(minimum=0.0, maximum=2 * np.pi),
+ psi=prior.Uniform(minimum=0.0, maximum=np.pi),
+ )
+ )
+ self.jump_proposal = bilby.gw.sampler.proposal.CorrelatedPolarisationPhaseJump(
+ priors=self.priors
+ )
def tearDown(self):
del self.priors
del self.jump_proposal
def test_jump_proposal_call_case_1(self):
- with mock.patch('random.random') as m:
+ with mock.patch("random.random") as m:
m.return_value = 0.3
sample = proposal.Sample(dict(phase=0.2, psi=0.5))
alpha = 3.0 * np.pi * 0.3
beta = 0.3
- expected = proposal.Sample(dict(phase=0.5*(alpha-beta), psi=0.5*(alpha+beta)))
+ expected = proposal.Sample(
+ dict(phase=0.5 * (alpha - beta), psi=0.5 * (alpha + beta))
+ )
self.assertEqual(expected, self.jump_proposal(sample, coordinates=None))
def test_jump_proposal_call_case_2(self):
- with mock.patch('random.random') as m:
+ with mock.patch("random.random") as m:
m.return_value = 0.7
sample = proposal.Sample(dict(phase=0.2, psi=0.5))
alpha = 0.7
beta = 3.0 * np.pi * 0.7 - 2 * np.pi
- expected = proposal.Sample(dict(phase=0.5*(alpha-beta), psi=0.5*(alpha+beta)))
+ expected = proposal.Sample(
+ dict(phase=0.5 * (alpha - beta), psi=0.5 * (alpha + beta))
+ )
self.assertEqual(expected, self.jump_proposal(sample))
class TestPolarisationPhaseJump(unittest.TestCase):
-
def setUp(self):
- self.priors = prior.PriorDict(dict(phase=prior.Uniform(minimum=0.0, maximum=2*np.pi),
- psi=prior.Uniform(minimum=0.0, maximum=np.pi)))
- self.jump_proposal = bilby.gw.sampler.proposal.PolarisationPhaseJump(priors=self.priors)
+ self.priors = prior.PriorDict(
+ dict(
+ phase=prior.Uniform(minimum=0.0, maximum=2 * np.pi),
+ psi=prior.Uniform(minimum=0.0, maximum=np.pi),
+ )
+ )
+ self.jump_proposal = bilby.gw.sampler.proposal.PolarisationPhaseJump(
+ priors=self.priors
+ )
def tearDown(self):
del self.priors
@@ -410,15 +503,18 @@ class TestPolarisationPhaseJump(unittest.TestCase):
def test_jump_proposal_call(self):
sample = proposal.Sample(dict(phase=0.2, psi=0.5))
- expected = proposal.Sample(dict(phase=0.2+np.pi, psi=0.5+np.pi/2))
+ expected = proposal.Sample(dict(phase=0.2 + np.pi, psi=0.5 + np.pi / 2))
self.assertEqual(expected, self.jump_proposal(sample))
class TestDrawFlatPrior(unittest.TestCase):
-
def setUp(self):
- self.priors = prior.PriorDict(dict(phase=prior.Uniform(minimum=0.0, maximum=2*np.pi),
- psi=prior.Cosine(minimum=0.0, maximum=np.pi)))
+ self.priors = prior.PriorDict(
+ dict(
+ phase=prior.Uniform(minimum=0.0, maximum=2 * np.pi),
+ psi=prior.Cosine(minimum=0.0, maximum=np.pi),
+ )
+ )
self.jump_proposal = proposal.DrawFlatPrior(priors=self.priors)
def tearDown(self):
@@ -426,7 +522,7 @@ class TestDrawFlatPrior(unittest.TestCase):
del self.jump_proposal
def test_jump_proposal_call(self):
- with mock.patch('bilby.core.prior.Uniform.sample') as m:
+ with mock.patch("bilby.core.prior.Uniform.sample") as m:
m.return_value = 0.3
sample = proposal.Sample(dict(phase=0.2, psi=0.5))
expected = proposal.Sample(dict(phase=0.3, psi=0.3))
diff --git a/test/result_test.py b/test/result_test.py
index c49f2ad182a568eb2816cbb6b3f12982dfc29397..991456928c91324bd5c25d6ec4356a77c4c88a6b 100644
--- a/test/result_test.py
+++ b/test/result_test.py
@@ -11,7 +11,6 @@ import bilby
class TestJson(unittest.TestCase):
-
def setUp(self):
self.encoder = bilby.core.utils.BilbyJsonEncoder
self.decoder = bilby.core.utils.decode_bilby_json
@@ -21,55 +20,63 @@ class TestJson(unittest.TestCase):
encoded = json.dumps(data, cls=self.encoder)
decoded = json.loads(encoded, object_hook=self.decoder)
self.assertEqual(data.keys(), decoded.keys())
- self.assertEqual(type(data['x']), type(decoded['x']))
- self.assertTrue(np.all(data['x'] == decoded['x']))
+ self.assertEqual(type(data["x"]), type(decoded["x"]))
+ self.assertTrue(np.all(data["x"] == decoded["x"]))
def test_array_encoding(self):
data = dict(x=np.array([1, 2, 3.4]))
encoded = json.dumps(data, cls=self.encoder)
decoded = json.loads(encoded, object_hook=self.decoder)
self.assertEqual(data.keys(), decoded.keys())
- self.assertEqual(type(data['x']), type(decoded['x']))
- self.assertTrue(np.all(data['x'] == decoded['x']))
+ self.assertEqual(type(data["x"]), type(decoded["x"]))
+ self.assertTrue(np.all(data["x"] == decoded["x"]))
def test_complex_encoding(self):
data = dict(x=1 + 3j)
encoded = json.dumps(data, cls=self.encoder)
decoded = json.loads(encoded, object_hook=self.decoder)
self.assertEqual(data.keys(), decoded.keys())
- self.assertEqual(type(data['x']), type(decoded['x']))
- self.assertTrue(np.all(data['x'] == decoded['x']))
+ self.assertEqual(type(data["x"]), type(decoded["x"]))
+ self.assertTrue(np.all(data["x"] == decoded["x"]))
def test_dataframe_encoding(self):
data = dict(data=pd.DataFrame(dict(x=[3, 4, 5], y=[5, 6, 7])))
encoded = json.dumps(data, cls=self.encoder)
decoded = json.loads(encoded, object_hook=self.decoder)
self.assertEqual(data.keys(), decoded.keys())
- self.assertEqual(type(data['data']), type(decoded['data']))
- self.assertTrue(np.all(data['data']['x'] == decoded['data']['x']))
- self.assertTrue(np.all(data['data']['y'] == decoded['data']['y']))
+ self.assertEqual(type(data["data"]), type(decoded["data"]))
+ self.assertTrue(np.all(data["data"]["x"] == decoded["data"]["x"]))
+ self.assertTrue(np.all(data["data"]["y"] == decoded["data"]["y"]))
class TestResult(unittest.TestCase):
-
def setUp(self):
np.random.seed(7)
bilby.utils.command_line_args.bilby_test_mode = False
- priors = bilby.prior.PriorDict(dict(
- x=bilby.prior.Uniform(0, 1, 'x', latex_label='$x$', unit='s'),
- y=bilby.prior.Uniform(0, 1, 'y', latex_label='$y$', unit='m'),
- c=1,
- d=2))
+ priors = bilby.prior.PriorDict(
+ dict(
+ x=bilby.prior.Uniform(0, 1, "x", latex_label="$x$", unit="s"),
+ y=bilby.prior.Uniform(0, 1, "y", latex_label="$y$", unit="m"),
+ c=1,
+ d=2,
+ )
+ )
result = bilby.core.result.Result(
- label='label', outdir='outdir', sampler='nestle',
- search_parameter_keys=['x', 'y'], fixed_parameter_keys=['c', 'd'],
- priors=priors, sampler_kwargs=dict(test='test', func=lambda x: x),
+ label="label",
+ outdir="outdir",
+ sampler="nestle",
+ search_parameter_keys=["x", "y"],
+ fixed_parameter_keys=["c", "d"],
+ priors=priors,
+ sampler_kwargs=dict(test="test", func=lambda x: x),
injection_parameters=dict(x=0.5, y=0.5),
- meta_data=dict(test='test'))
+ meta_data=dict(test="test"),
+ )
n = 100
- posterior = pd.DataFrame(dict(x=np.random.normal(0, 1, n),
- y=np.random.normal(0, 1, n)))
+ posterior = pd.DataFrame(
+ dict(x=np.random.normal(0, 1, n), y=np.random.normal(0, 1, n))
+ )
result.posterior = posterior
result.log_evidence = 10
result.log_evidence_err = 11
@@ -88,47 +95,63 @@ class TestResult(unittest.TestCase):
pass
def test_result_file_name_default(self):
- outdir = 'outdir'
- label = 'label'
- self.assertEqual(bilby.core.result.result_file_name(outdir, label),
- '{}/{}_result.json'.format(outdir, label))
+ outdir = "outdir"
+ label = "label"
+ self.assertEqual(
+ bilby.core.result.result_file_name(outdir, label),
+ "{}/{}_result.json".format(outdir, label),
+ )
def test_result_file_name_hdf5(self):
- outdir = 'outdir'
- label = 'label'
- self.assertEqual(bilby.core.result.result_file_name(outdir, label, extension='hdf5'),
- '{}/{}_result.hdf5'.format(outdir, label))
+ outdir = "outdir"
+ label = "label"
+ self.assertEqual(
+ bilby.core.result.result_file_name(outdir, label, extension="hdf5"),
+ "{}/{}_result.hdf5".format(outdir, label),
+ )
def test_fail_save_and_load(self):
with self.assertRaises(ValueError):
bilby.core.result.read_in_result()
with self.assertRaises(ValueError):
- bilby.core.result.read_in_result(filename='no_file_extension')
+ bilby.core.result.read_in_result(filename="no_file_extension")
with self.assertRaises(IOError):
- bilby.core.result.read_in_result(filename='not/a/file.json')
+ bilby.core.result.read_in_result(filename="not/a/file.json")
def test_unset_priors(self):
result = bilby.core.result.Result(
- label='label', outdir='outdir', sampler='nestle',
- search_parameter_keys=['x', 'y'], fixed_parameter_keys=['c', 'd'],
- priors=None, sampler_kwargs=dict(test='test'),
+ label="label",
+ outdir="outdir",
+ sampler="nestle",
+ search_parameter_keys=["x", "y"],
+ fixed_parameter_keys=["c", "d"],
+ priors=None,
+ sampler_kwargs=dict(test="test"),
injection_parameters=dict(x=0.5, y=0.5),
- meta_data=dict(test='test'))
+ meta_data=dict(test="test"),
+ )
with self.assertRaises(ValueError):
_ = result.priors
self.assertEqual(result.parameter_labels, result.search_parameter_keys)
- self.assertEqual(result.parameter_labels_with_unit, result.search_parameter_keys)
+ self.assertEqual(
+ result.parameter_labels_with_unit, result.search_parameter_keys
+ )
def test_unknown_priors_fail(self):
with self.assertRaises(ValueError):
bilby.core.result.Result(
- label='label', outdir='outdir', sampler='nestle',
- search_parameter_keys=['x', 'y'], fixed_parameter_keys=['c', 'd'],
- priors=['a', 'b'], sampler_kwargs=dict(test='test'),
+ label="label",
+ outdir="outdir",
+ sampler="nestle",
+ search_parameter_keys=["x", "y"],
+ fixed_parameter_keys=["c", "d"],
+ priors=["a", "b"],
+ sampler_kwargs=dict(test="test"),
injection_parameters=dict(x=0.5, y=0.5),
- meta_data=dict(test='test'))
+ meta_data=dict(test="test"),
+ )
def test_set_samples(self):
samples = [1, 2, 3]
@@ -156,129 +179,189 @@ class TestResult(unittest.TestCase):
_ = self.result.posterior
def test_save_and_load_hdf5(self):
- self.result.save_to_file(extension='hdf5')
+ self.result.save_to_file(extension="hdf5")
loaded_result = bilby.core.result.read_in_result(
- outdir=self.result.outdir, label=self.result.label, extension='hdf5')
- self.assertTrue(pd.DataFrame.equals
- (self.result.posterior, loaded_result.posterior))
- self.assertTrue(self.result.fixed_parameter_keys == loaded_result.fixed_parameter_keys)
- self.assertTrue(self.result.search_parameter_keys == loaded_result.search_parameter_keys)
+ outdir=self.result.outdir, label=self.result.label, extension="hdf5"
+ )
+ self.assertTrue(
+ pd.DataFrame.equals(self.result.posterior, loaded_result.posterior)
+ )
+ self.assertTrue(
+ self.result.fixed_parameter_keys == loaded_result.fixed_parameter_keys
+ )
+ self.assertTrue(
+ self.result.search_parameter_keys == loaded_result.search_parameter_keys
+ )
self.assertEqual(self.result.meta_data, loaded_result.meta_data)
- self.assertEqual(self.result.injection_parameters, loaded_result.injection_parameters)
+ self.assertEqual(
+ self.result.injection_parameters, loaded_result.injection_parameters
+ )
self.assertEqual(self.result.log_evidence, loaded_result.log_evidence)
- self.assertEqual(self.result.log_noise_evidence, loaded_result.log_noise_evidence)
+ self.assertEqual(
+ self.result.log_noise_evidence, loaded_result.log_noise_evidence
+ )
self.assertEqual(self.result.log_evidence_err, loaded_result.log_evidence_err)
self.assertEqual(self.result.log_bayes_factor, loaded_result.log_bayes_factor)
- self.assertEqual(self.result.priors['x'], loaded_result.priors['x'])
- self.assertEqual(self.result.priors['y'], loaded_result.priors['y'])
- self.assertEqual(self.result.priors['c'], loaded_result.priors['c'])
- self.assertEqual(self.result.priors['d'], loaded_result.priors['d'])
+ self.assertEqual(self.result.priors["x"], loaded_result.priors["x"])
+ self.assertEqual(self.result.priors["y"], loaded_result.priors["y"])
+ self.assertEqual(self.result.priors["c"], loaded_result.priors["c"])
+ self.assertEqual(self.result.priors["d"], loaded_result.priors["d"])
def test_save_and_load_default(self):
self.result.save_to_file()
loaded_result = bilby.core.result.read_in_result(
- outdir=self.result.outdir, label=self.result.label)
- self.assertTrue(np.array_equal
- (self.result.posterior.sort_values(by=['x']),
- loaded_result.posterior.sort_values(by=['x'])))
- self.assertTrue(self.result.fixed_parameter_keys == loaded_result.fixed_parameter_keys)
- self.assertTrue(self.result.search_parameter_keys == loaded_result.search_parameter_keys)
+ outdir=self.result.outdir, label=self.result.label
+ )
+ self.assertTrue(
+ np.array_equal(
+ self.result.posterior.sort_values(by=["x"]),
+ loaded_result.posterior.sort_values(by=["x"]),
+ )
+ )
+ self.assertTrue(
+ self.result.fixed_parameter_keys == loaded_result.fixed_parameter_keys
+ )
+ self.assertTrue(
+ self.result.search_parameter_keys == loaded_result.search_parameter_keys
+ )
self.assertEqual(self.result.meta_data, loaded_result.meta_data)
- self.assertEqual(self.result.injection_parameters, loaded_result.injection_parameters)
+ self.assertEqual(
+ self.result.injection_parameters, loaded_result.injection_parameters
+ )
self.assertEqual(self.result.log_evidence, loaded_result.log_evidence)
- self.assertEqual(self.result.log_noise_evidence, loaded_result.log_noise_evidence)
+ self.assertEqual(
+ self.result.log_noise_evidence, loaded_result.log_noise_evidence
+ )
self.assertEqual(self.result.log_evidence_err, loaded_result.log_evidence_err)
self.assertEqual(self.result.log_bayes_factor, loaded_result.log_bayes_factor)
- self.assertEqual(self.result.priors['x'], loaded_result.priors['x'])
- self.assertEqual(self.result.priors['y'], loaded_result.priors['y'])
- self.assertEqual(self.result.priors['c'], loaded_result.priors['c'])
- self.assertEqual(self.result.priors['d'], loaded_result.priors['d'])
+ self.assertEqual(self.result.priors["x"], loaded_result.priors["x"])
+ self.assertEqual(self.result.priors["y"], loaded_result.priors["y"])
+ self.assertEqual(self.result.priors["c"], loaded_result.priors["c"])
+ self.assertEqual(self.result.priors["d"], loaded_result.priors["d"])
def test_save_and_load_gzip(self):
self.result.save_to_file(gzip=True)
loaded_result = bilby.core.result.read_in_result(
- outdir=self.result.outdir, label=self.result.label, gzip=True)
- self.assertTrue(np.array_equal
- (self.result.posterior.sort_values(by=['x']),
- loaded_result.posterior.sort_values(by=['x'])))
- self.assertTrue(self.result.fixed_parameter_keys == loaded_result.fixed_parameter_keys)
- self.assertTrue(self.result.search_parameter_keys == loaded_result.search_parameter_keys)
+ outdir=self.result.outdir, label=self.result.label, gzip=True
+ )
+ self.assertTrue(
+ np.array_equal(
+ self.result.posterior.sort_values(by=["x"]),
+ loaded_result.posterior.sort_values(by=["x"]),
+ )
+ )
+ self.assertTrue(
+ self.result.fixed_parameter_keys == loaded_result.fixed_parameter_keys
+ )
+ self.assertTrue(
+ self.result.search_parameter_keys == loaded_result.search_parameter_keys
+ )
self.assertEqual(self.result.meta_data, loaded_result.meta_data)
- self.assertEqual(self.result.injection_parameters, loaded_result.injection_parameters)
+ self.assertEqual(
+ self.result.injection_parameters, loaded_result.injection_parameters
+ )
self.assertEqual(self.result.log_evidence, loaded_result.log_evidence)
- self.assertEqual(self.result.log_noise_evidence, loaded_result.log_noise_evidence)
+ self.assertEqual(
+ self.result.log_noise_evidence, loaded_result.log_noise_evidence
+ )
self.assertEqual(self.result.log_evidence_err, loaded_result.log_evidence_err)
self.assertEqual(self.result.log_bayes_factor, loaded_result.log_bayes_factor)
- self.assertEqual(self.result.priors['x'], loaded_result.priors['x'])
- self.assertEqual(self.result.priors['y'], loaded_result.priors['y'])
- self.assertEqual(self.result.priors['c'], loaded_result.priors['c'])
- self.assertEqual(self.result.priors['d'], loaded_result.priors['d'])
+ self.assertEqual(self.result.priors["x"], loaded_result.priors["x"])
+ self.assertEqual(self.result.priors["y"], loaded_result.priors["y"])
+ self.assertEqual(self.result.priors["c"], loaded_result.priors["c"])
+ self.assertEqual(self.result.priors["d"], loaded_result.priors["d"])
def test_save_and_dont_overwrite_default(self):
shutil.rmtree(
- '{}/{}_result.json.old'.format(self.result.outdir, self.result.label),
- ignore_errors=True)
+ "{}/{}_result.json.old".format(self.result.outdir, self.result.label),
+ ignore_errors=True,
+ )
self.result.save_to_file(overwrite=False)
self.result.save_to_file(overwrite=False)
- self.assertTrue(os.path.isfile(
- '{}/{}_result.json.old'.format(self.result.outdir, self.result.label)))
+ self.assertTrue(
+ os.path.isfile(
+ "{}/{}_result.json.old".format(self.result.outdir, self.result.label)
+ )
+ )
def test_save_and_dont_overwrite_hdf5(self):
shutil.rmtree(
- '{}/{}_result.hdf5.old'.format(self.result.outdir, self.result.label),
- ignore_errors=True)
- self.result.save_to_file(overwrite=False, extension='hdf5')
- self.result.save_to_file(overwrite=False, extension='hdf5')
- self.assertTrue(os.path.isfile(
- '{}/{}_result.hdf5.old'.format(self.result.outdir, self.result.label)))
+ "{}/{}_result.hdf5.old".format(self.result.outdir, self.result.label),
+ ignore_errors=True,
+ )
+ self.result.save_to_file(overwrite=False, extension="hdf5")
+ self.result.save_to_file(overwrite=False, extension="hdf5")
+ self.assertTrue(
+ os.path.isfile(
+ "{}/{}_result.hdf5.old".format(self.result.outdir, self.result.label)
+ )
+ )
def test_save_and_overwrite_hdf5(self):
shutil.rmtree(
- '{}/{}_result.hdf5.old'.format(self.result.outdir, self.result.label),
- ignore_errors=True)
- self.result.save_to_file(overwrite=True, extension='hdf5')
- self.result.save_to_file(overwrite=True, extension='hdf5')
- self.assertFalse(os.path.isfile(
- '{}/{}_result.hdf5.old'.format(self.result.outdir, self.result.label)))
+ "{}/{}_result.hdf5.old".format(self.result.outdir, self.result.label),
+ ignore_errors=True,
+ )
+ self.result.save_to_file(overwrite=True, extension="hdf5")
+ self.result.save_to_file(overwrite=True, extension="hdf5")
+ self.assertFalse(
+ os.path.isfile(
+ "{}/{}_result.hdf5.old".format(self.result.outdir, self.result.label)
+ )
+ )
def test_save_and_overwrite_default(self):
shutil.rmtree(
- '{}/{}_result.json.old'.format(self.result.outdir, self.result.label),
- ignore_errors=True)
- self.result.save_to_file(overwrite=True, extension='hdf5')
- self.result.save_to_file(overwrite=True, extension='hdf5')
- self.assertFalse(os.path.isfile(
- '{}/{}_result.h5.old'.format(self.result.outdir, self.result.label)))
-
- def test_save_and_overwrite_default(self):
+ "{}/{}_result.json.old".format(self.result.outdir, self.result.label),
+ ignore_errors=True,
+ )
+ self.result.save_to_file(overwrite=True, extension="hdf5")
+ self.result.save_to_file(overwrite=True, extension="hdf5")
+ self.assertFalse(
+ os.path.isfile(
+ "{}/{}_result.h5.old".format(self.result.outdir, self.result.label)
+ )
+ )
+
+ def test_save_and_overwrite_default_2(self):
shutil.rmtree(
- '{}/{}_result.json.old'.format(self.result.outdir, self.result.label),
- ignore_errors=True)
+ "{}/{}_result.json.old".format(self.result.outdir, self.result.label),
+ ignore_errors=True,
+ )
self.result.save_to_file(overwrite=True)
self.result.save_to_file(overwrite=True)
- self.assertFalse(os.path.isfile(
- '{}/{}_result.json.old'.format(self.result.outdir, self.result.label)))
+ self.assertFalse(
+ os.path.isfile(
+ "{}/{}_result.json.old".format(self.result.outdir, self.result.label)
+ )
+ )
def test_save_samples(self):
self.result.save_posterior_samples()
- filename = '{}/{}_posterior_samples.dat'.format(self.result.outdir, self.result.label)
+ filename = "{}/{}_posterior_samples.dat".format(
+ self.result.outdir, self.result.label
+ )
self.assertTrue(os.path.isfile(filename))
- df = pd.read_csv(filename, sep=' ')
+ df = pd.read_csv(filename, sep=" ")
self.assertTrue(np.allclose(self.result.posterior.values, df.values))
def test_save_samples_from_filename(self):
- filename = '{}/{}_posterior_samples_OTHER.dat'.format(self.result.outdir, self.result.label)
+ filename = "{}/{}_posterior_samples_OTHER.dat".format(
+ self.result.outdir, self.result.label
+ )
self.result.save_posterior_samples(filename=filename)
self.assertTrue(os.path.isfile(filename))
- df = pd.read_csv(filename, sep=' ')
+ df = pd.read_csv(filename, sep=" ")
self.assertTrue(np.allclose(self.result.posterior.values, df.values))
def test_save_samples_numpy_load(self):
self.result.save_posterior_samples()
- filename = '{}/{}_posterior_samples.dat'.format(self.result.outdir, self.result.label)
+ filename = "{}/{}_posterior_samples.dat".format(
+ self.result.outdir, self.result.label
+ )
self.assertTrue(os.path.isfile(filename))
data = np.genfromtxt(filename, names=True)
- df = pd.read_csv(filename, sep=' ')
+ df = pd.read_csv(filename, sep=" ")
self.assertTrue(len(data.dtype) == len(df.keys()))
def test_samples_to_posterior_simple(self):
@@ -287,10 +370,9 @@ class TestResult(unittest.TestCase):
y = [4, 6, 8]
self.result.samples = np.array([x, y]).T
self.result.samples_to_posterior()
- self.assertTrue(all(self.result.posterior['x'] == x))
- self.assertTrue(all(self.result.posterior['y'] == y))
- self.assertTrue(np.all(
- None == self.result.posterior.log_likelihood.values))
+ self.assertTrue(all(self.result.posterior["x"] == x))
+ self.assertTrue(all(self.result.posterior["y"] == y))
+ self.assertTrue(np.all(None == self.result.posterior.log_likelihood.values)) # noqa
def test_samples_to_posterior(self):
self.result.posterior = None
@@ -300,20 +382,25 @@ class TestResult(unittest.TestCase):
self.result.samples = np.array([x, y]).T
self.result.log_likelihood_evaluations = log_likelihood
self.result.samples_to_posterior(priors=self.result.priors)
- self.assertTrue(all(self.result.posterior['x'] == x))
- self.assertTrue(all(self.result.posterior['y'] == y))
- self.assertTrue(np.array_equal(self.result.posterior.log_likelihood.values, log_likelihood))
- self.assertTrue(all(self.result.posterior.c.values == self.result.priors['c'].peak))
- self.assertTrue(all(self.result.posterior.d.values == self.result.priors['d'].peak))
+ self.assertTrue(all(self.result.posterior["x"] == x))
+ self.assertTrue(all(self.result.posterior["y"] == y))
+ self.assertTrue(
+ np.array_equal(self.result.posterior.log_likelihood.values, log_likelihood)
+ )
+ self.assertTrue(
+ all(self.result.posterior.c.values == self.result.priors["c"].peak)
+ )
+ self.assertTrue(
+ all(self.result.posterior.d.values == self.result.priors["d"].peak)
+ )
def test_calculate_prior_values(self):
self.result.calculate_prior_values(priors=self.result.priors)
self.assertEqual(len(self.result.posterior), len(self.result.prior_values))
def test_plot_multiple(self):
- filename = 'multiple.png'.format(self.result.outdir)
- bilby.core.result.plot_multiple([self.result, self.result],
- filename=filename)
+ filename = "multiple.png".format(self.result.outdir)
+ bilby.core.result.plot_multiple([self.result, self.result], filename=filename)
self.assertTrue(os.path.isfile(filename))
os.remove(filename)
@@ -322,8 +409,10 @@ class TestResult(unittest.TestCase):
self.result.nburn = 5
self.result.plot_walkers()
self.assertTrue(
- os.path.isfile('{}/{}_walkers.png'.format(
- self.result.outdir, self.result.label)))
+ os.path.isfile(
+ "{}/{}_walkers.png".format(self.result.outdir, self.result.label)
+ )
+ )
def test_plot_with_data(self):
x = np.linspace(0, 1, 10)
@@ -331,19 +420,24 @@ class TestResult(unittest.TestCase):
def model(xx, theta):
return xx
+
self.result.posterior = pd.DataFrame(dict(theta=[1, 2, 3]))
self.result.plot_with_data(model, x, y, ndraws=10)
self.assertTrue(
- os.path.isfile('{}/{}_plot_with_data.png'.format(
- self.result.outdir, self.result.label)))
- self.result.posterior['log_likelihood'] = np.random.uniform(0, 1, len(self.result.posterior))
- self.result.plot_with_data(model, x, y, ndraws=10, xlabel='a', ylabel='y')
+ os.path.isfile(
+ "{}/{}_plot_with_data.png".format(self.result.outdir, self.result.label)
+ )
+ )
+ self.result.posterior["log_likelihood"] = np.random.uniform(
+ 0, 1, len(self.result.posterior)
+ )
+ self.result.plot_with_data(model, x, y, ndraws=10, xlabel="a", ylabel="y")
def test_plot_corner(self):
self.result.injection_parameters = dict(x=0.8, y=1.1)
self.result.plot_corner()
- self.result.plot_corner(parameters=['x', 'y'])
- self.result.plot_corner(parameters=['x', 'y'], truths=[1, 1])
+ self.result.plot_corner(parameters=["x", "y"])
+ self.result.plot_corner(parameters=["x", "y"], truths=[1, 1])
self.result.plot_corner(parameters=dict(x=1, y=1))
self.result.plot_corner(truths=dict(x=1, y=1))
self.result.plot_corner(truth=dict(x=1, y=1))
@@ -351,30 +445,27 @@ class TestResult(unittest.TestCase):
self.result.plot_corner(truths=False)
self.result.plot_corner(truths=True)
with self.assertRaises(ValueError):
- self.result.plot_corner(truths=dict(x=1, y=1),
- parameters=dict(x=1, y=1))
+ self.result.plot_corner(truths=dict(x=1, y=1), parameters=dict(x=1, y=1))
with self.assertRaises(ValueError):
- self.result.plot_corner(truths=[1, 1],
- parameters=dict(x=1, y=1))
+ self.result.plot_corner(truths=[1, 1], parameters=dict(x=1, y=1))
with self.assertRaises(ValueError):
- self.result.plot_corner(parameters=['x', 'y'],
- truths=dict(x=1, y=1))
+ self.result.plot_corner(parameters=["x", "y"], truths=dict(x=1, y=1))
def test_plot_corner_with_injection_parameters(self):
self.result.plot_corner()
- self.result.plot_corner(parameters=['x', 'y'])
- self.result.plot_corner(parameters=['x', 'y'], truths=[1, 1])
+ self.result.plot_corner(parameters=["x", "y"])
+ self.result.plot_corner(parameters=["x", "y"], truths=[1, 1])
self.result.plot_corner(parameters=dict(x=1, y=1))
def test_plot_corner_with_priors(self):
priors = bilby.core.prior.PriorDict()
- priors['x'] = bilby.core.prior.Uniform(-1, 1, 'x')
- priors['y'] = bilby.core.prior.Uniform(-1, 1, 'y')
+ priors["x"] = bilby.core.prior.Uniform(-1, 1, "x")
+ priors["y"] = bilby.core.prior.Uniform(-1, 1, "y")
self.result.plot_corner(priors=priors)
self.result.priors = priors
self.result.plot_corner(priors=True)
with self.assertRaises(ValueError):
- self.result.plot_corner(priors='test')
+ self.result.plot_corner(priors="test")
def test_get_credible_levels(self):
levels = self.result.get_all_injection_credible_levels()
@@ -388,57 +479,74 @@ class TestResult(unittest.TestCase):
def test_kde(self):
kde = self.result.kde
import scipy.stats
+
self.assertEqual(type(kde), scipy.stats.kde.gaussian_kde)
self.assertEqual(kde.d, 2)
def test_posterior_probability(self):
sample = dict(x=0, y=0.1)
self.assertTrue(
- isinstance(self.result.posterior_probability(sample), np.ndarray))
- self.assertTrue(
- len(self.result.posterior_probability(sample)), 1)
+ isinstance(self.result.posterior_probability(sample), np.ndarray)
+ )
+ self.assertTrue(len(self.result.posterior_probability(sample)), 1)
self.assertEqual(
- self.result.posterior_probability(sample)[0],
- self.result.kde([0, 0.1]))
+ self.result.posterior_probability(sample)[0], self.result.kde([0, 0.1])
+ )
def test_multiple_posterior_probability(self):
sample = [dict(x=0, y=0.1), dict(x=0.8, y=0)]
self.assertTrue(
- isinstance(self.result.posterior_probability(sample), np.ndarray))
- self.assertTrue(np.array_equal(self.result.posterior_probability(sample),
- self.result.kde([[0, 0.1], [0.8, 0]])))
+ isinstance(self.result.posterior_probability(sample), np.ndarray)
+ )
+ self.assertTrue(
+ np.array_equal(
+ self.result.posterior_probability(sample),
+ self.result.kde([[0, 0.1], [0.8, 0]]),
+ )
+ )
class TestResultListError(unittest.TestCase):
-
def setUp(self):
np.random.seed(7)
bilby.utils.command_line_args.bilby_test_mode = False
- self.priors = bilby.prior.PriorDict(dict(
- x=bilby.prior.Uniform(0, 1, 'x', latex_label='$x$', unit='s'),
- y=bilby.prior.Uniform(0, 1, 'y', latex_label='$y$', unit='m'),
- c=1,
- d=2))
+ self.priors = bilby.prior.PriorDict(
+ dict(
+ x=bilby.prior.Uniform(0, 1, "x", latex_label="$x$", unit="s"),
+ y=bilby.prior.Uniform(0, 1, "y", latex_label="$y$", unit="m"),
+ c=1,
+ d=2,
+ )
+ )
# create two cpnest results
self.nested_results = bilby.result.ResultList([])
self.mcmc_results = bilby.result.ResultList([])
self.expected_nested = []
- self.outdir = 'outdir'
- self.label = 'label'
+ self.outdir = "outdir"
+ self.label = "label"
n = 100
for i in range(2):
result = bilby.core.result.Result(
- label=self.label + str(i), outdir=self.outdir, sampler='cpnest',
- search_parameter_keys=['x', 'y'], fixed_parameter_keys=['c', 'd'],
- priors=self.priors, sampler_kwargs=dict(test='test', func=lambda x: x, nlive=10),
+ label=self.label + str(i),
+ outdir=self.outdir,
+ sampler="cpnest",
+ search_parameter_keys=["x", "y"],
+ fixed_parameter_keys=["c", "d"],
+ priors=self.priors,
+ sampler_kwargs=dict(test="test", func=lambda x: x, nlive=10),
injection_parameters=dict(x=0.5, y=0.5),
- meta_data=dict(test='test'))
-
- posterior = pd.DataFrame(dict(x=np.random.normal(0, 1, n),
- y=np.random.normal(0, 1, n),
- log_likelihood=sorted(np.random.normal(0, 1, n))))
+ meta_data=dict(test="test"),
+ )
+
+ posterior = pd.DataFrame(
+ dict(
+ x=np.random.normal(0, 1, n),
+ y=np.random.normal(0, 1, n),
+ log_likelihood=sorted(np.random.normal(0, 1, n)),
+ )
+ )
result.posterior = posterior[-10:] # use last 10 samples as posterior
result.nested_samples = posterior
result.log_evidence = 10
@@ -449,15 +557,24 @@ class TestResultListError(unittest.TestCase):
self.expected_nested.append(result)
for i in range(2):
result = bilby.core.result.Result(
- label=self.label + str(i) + 'mcmc', outdir=self.outdir, sampler='emcee',
- search_parameter_keys=['x', 'y'], fixed_parameter_keys=['c', 'd'],
- priors=self.priors, sampler_kwargs=dict(test='test', func=lambda x: x, nlive=10),
+ label=self.label + str(i) + "mcmc",
+ outdir=self.outdir,
+ sampler="emcee",
+ search_parameter_keys=["x", "y"],
+ fixed_parameter_keys=["c", "d"],
+ priors=self.priors,
+ sampler_kwargs=dict(test="test", func=lambda x: x, nlive=10),
injection_parameters=dict(x=0.5, y=0.5),
- meta_data=dict(test='test'))
-
- posterior = pd.DataFrame(dict(x=np.random.normal(0, 1, n),
- y=np.random.normal(0, 1, n),
- log_likelihood=sorted(np.random.normal(0, 1, n))))
+ meta_data=dict(test="test"),
+ )
+
+ posterior = pd.DataFrame(
+ dict(
+ x=np.random.normal(0, 1, n),
+ y=np.random.normal(0, 1, n),
+ log_likelihood=sorted(np.random.normal(0, 1, n)),
+ )
+ )
result.posterior = posterior[-10:]
result.log_evidence = 10
result.log_evidence_err = 11
@@ -486,7 +603,7 @@ class TestResultListError(unittest.TestCase):
_ = bilby.core.result.ResultList(1)
def test_append_from_string(self):
- self.nested_results.append(self.outdir + '/' + self.label + '1_result.json')
+ self.nested_results.append(self.outdir + "/" + self.label + "1_result.json")
self.assertEqual(3, len(self.nested_results))
def test_append_result_type(self):
@@ -495,29 +612,35 @@ class TestResultListError(unittest.TestCase):
self.assertListEqual(self.nested_results, self.nested_results)
def test_combine_inconsistent_samplers(self):
- self.nested_results[0].sampler = 'dynesty'
+ self.nested_results[0].sampler = "dynesty"
with self.assertRaises(bilby.result.ResultListError):
self.nested_results.combine()
def test_combine_inconsistent_priors_length(self):
- self.nested_results[0].priors = bilby.prior.PriorDict(dict(
- x=bilby.prior.Uniform(0, 1, 'x', latex_label='$x$', unit='s'),
- y=bilby.prior.Uniform(0, 1, 'y', latex_label='$y$', unit='m'),
- c=1))
+ self.nested_results[0].priors = bilby.prior.PriorDict(
+ dict(
+ x=bilby.prior.Uniform(0, 1, "x", latex_label="$x$", unit="s"),
+ y=bilby.prior.Uniform(0, 1, "y", latex_label="$y$", unit="m"),
+ c=1,
+ )
+ )
with self.assertRaises(bilby.result.ResultListError):
self.nested_results.combine()
def test_combine_inconsistent_priors_types(self):
- self.nested_results[0].priors = bilby.prior.PriorDict(dict(
- x=bilby.prior.Uniform(0, 1, 'x', latex_label='$x$', unit='s'),
- y=bilby.prior.Uniform(0, 1, 'y', latex_label='$y$', unit='m'),
- c=1,
- d=bilby.core.prior.Cosine()))
+ self.nested_results[0].priors = bilby.prior.PriorDict(
+ dict(
+ x=bilby.prior.Uniform(0, 1, "x", latex_label="$x$", unit="s"),
+ y=bilby.prior.Uniform(0, 1, "y", latex_label="$y$", unit="m"),
+ c=1,
+ d=bilby.core.prior.Cosine(),
+ )
+ )
with self.assertRaises(bilby.result.ResultListError):
self.nested_results.combine()
def test_combine_inconsistent_search_parameters(self):
- self.nested_results[0].search_parameter_keys = ['y']
+ self.nested_results[0].search_parameter_keys = ["y"]
with self.assertRaises(bilby.result.ResultListError):
self.nested_results.combine()
@@ -533,15 +656,24 @@ class TestResultListError(unittest.TestCase):
def test_combine_inconsistent_sampling_data(self):
result = bilby.core.result.Result(
- label=self.label, outdir=self.outdir, sampler='cpnest',
- search_parameter_keys=['x', 'y'], fixed_parameter_keys=['c', 'd'],
- priors=self.priors, sampler_kwargs=dict(test='test', func=lambda x: x, nlive=10),
+ label=self.label,
+ outdir=self.outdir,
+ sampler="cpnest",
+ search_parameter_keys=["x", "y"],
+ fixed_parameter_keys=["c", "d"],
+ priors=self.priors,
+ sampler_kwargs=dict(test="test", func=lambda x: x, nlive=10),
injection_parameters=dict(x=0.5, y=0.5),
- meta_data=dict(test='test'))
-
- posterior = pd.DataFrame(dict(x=np.random.normal(0, 1, 100),
- y=np.random.normal(0, 1, 100),
- log_likelihood=sorted(np.random.normal(0, 1, 100))))
+ meta_data=dict(test="test"),
+ )
+
+ posterior = pd.DataFrame(
+ dict(
+ x=np.random.normal(0, 1, 100),
+ y=np.random.normal(0, 1, 100),
+ log_likelihood=sorted(np.random.normal(0, 1, 100)),
+ )
+ )
result.posterior = posterior[-10:] # use last 10 samples as posterior
result.log_evidence = 10
result.log_evidence_err = 11
@@ -553,5 +685,5 @@ class TestResultListError(unittest.TestCase):
self.nested_results.combine()
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/sample_from_the_prior_test.py b/test/sample_from_the_prior_test.py
index aeda281ae4c835ed60eb00389418ff5839430ceb..5761d19b52de4d3781ac506d73072438fb8507d4 100644
--- a/test/sample_from_the_prior_test.py
+++ b/test/sample_from_the_prior_test.py
@@ -19,7 +19,7 @@ def ks_2samp_wrapper(data1, data2):
class Test(unittest.TestCase):
- outdir = 'outdir_for_tests'
+ outdir = "outdir_for_tests"
@classmethod
def setUpClass(self):
@@ -27,8 +27,7 @@ class Test(unittest.TestCase):
try:
shutil.rmtree(self.outdir)
except OSError:
- logging.warning(
- "{} not removed prior to tests".format(self.outdir))
+ logging.warning("{} not removed prior to tests".format(self.outdir))
@classmethod
def tearDownClass(self):
@@ -36,57 +35,78 @@ class Test(unittest.TestCase):
try:
shutil.rmtree(self.outdir)
except OSError:
- logging.warning(
- "{} not removed prior to tests".format(self.outdir))
+ logging.warning("{} not removed prior to tests".format(self.outdir))
def test_fifteen_dimensional_cbc(self):
- duration = 4.
- sampling_frequency = 2048.
- label = 'full_15_parameters'
+ duration = 4.0
+ sampling_frequency = 2048.0
+ label = "full_15_parameters"
np.random.seed(8817023)
- waveform_arguments = dict(waveform_approximant='IMRPhenomPv2',
- reference_frequency=50., minimum_frequency=20.)
+ waveform_arguments = dict(
+ waveform_approximant="IMRPhenomPv2",
+ reference_frequency=50.0,
+ minimum_frequency=20.0,
+ )
waveform_generator = bilby.gw.WaveformGenerator(
- duration=duration, sampling_frequency=sampling_frequency,
+ duration=duration,
+ sampling_frequency=sampling_frequency,
frequency_domain_source_model=bilby.gw.source.lal_binary_black_hole,
parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
- waveform_arguments=waveform_arguments)
+ waveform_arguments=waveform_arguments,
+ )
- ifos = bilby.gw.detector.InterferometerList(['H1', 'L1'])
+ ifos = bilby.gw.detector.InterferometerList(["H1", "L1"])
ifos.set_strain_data_from_power_spectral_densities(
- sampling_frequency=sampling_frequency, duration=duration,
- start_time=0)
+ sampling_frequency=sampling_frequency, duration=duration, start_time=0
+ )
priors = bilby.gw.prior.BBHPriorDict()
- priors.pop('mass_1')
- priors.pop('mass_2')
- priors['chirp_mass'] = bilby.prior.Uniform(
- name='chirp_mass', latex_label='$M$', minimum=10.0, maximum=100.0,
- unit='$M_{\\odot}$')
- priors['mass_ratio'] = bilby.prior.Uniform(
- name='mass_ratio', latex_label='$q$', minimum=0.5, maximum=1.0)
- priors['geocent_time'] = bilby.core.prior.Uniform(
- minimum=-0.1, maximum=0.1)
+ priors.pop("mass_1")
+ priors.pop("mass_2")
+ priors["chirp_mass"] = bilby.prior.Uniform(
+ name="chirp_mass",
+ latex_label="$M$",
+ minimum=10.0,
+ maximum=100.0,
+ unit="$M_{\\odot}$",
+ )
+ priors["mass_ratio"] = bilby.prior.Uniform(
+ name="mass_ratio", latex_label="$q$", minimum=0.5, maximum=1.0
+ )
+ priors["geocent_time"] = bilby.core.prior.Uniform(minimum=-0.1, maximum=0.1)
likelihood = bilby.gw.GravitationalWaveTransient(
- interferometers=ifos, waveform_generator=waveform_generator,
- priors=priors, distance_marginalization=False,
- phase_marginalization=False, time_marginalization=False)
+ interferometers=ifos,
+ waveform_generator=waveform_generator,
+ priors=priors,
+ distance_marginalization=False,
+ phase_marginalization=False,
+ time_marginalization=False,
+ )
likelihood = bilby.core.likelihood.ZeroLikelihood(likelihood)
result = bilby.run_sampler(
- likelihood=likelihood, priors=priors, sampler='dynesty',
- npoints=1000, walks=100, outdir=self.outdir, label=label)
- pvalues = [ks_2samp_wrapper(result.priors[key].sample(10000),
- result.posterior[key].values).pvalue
- for key in priors.keys()]
+ likelihood=likelihood,
+ priors=priors,
+ sampler="dynesty",
+ npoints=1000,
+ walks=100,
+ outdir=self.outdir,
+ label=label,
+ )
+ pvalues = [
+ ks_2samp_wrapper(
+ result.priors[key].sample(10000), result.posterior[key].values
+ ).pvalue
+ for key in priors.keys()
+ ]
print("P values per parameter")
for key, p in zip(priors.keys(), pvalues):
print(key, p)
self.assertGreater(kstest(pvalues, "uniform").pvalue, 0.01)
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/sampler_test.py b/test/sampler_test.py
index 92dffc37afb7805bf39eec445a79b8833185524b..f5399770033b2301bc5b6784a11e7225706134c4 100644
--- a/test/sampler_test.py
+++ b/test/sampler_test.py
@@ -10,7 +10,6 @@ import copy
class TestSampler(unittest.TestCase):
-
def setUp(self):
likelihood = bilby.core.likelihood.Likelihood()
likelihood.parameters = dict(a=1, b=2, c=3)
@@ -23,27 +22,34 @@ class TestSampler(unittest.TestCase):
uniform_prior.prob = MagicMock(return_value=1)
uniform_prior.sample = MagicMock(return_value=0.5)
- priors = dict(a=delta_prior, b='string', c=uniform_prior)
+ priors = dict(a=delta_prior, b="string", c=uniform_prior)
likelihood.log_likelihood_ratio = MagicMock(return_value=1)
likelihood.log_likelihood = MagicMock(return_value=2)
- test_directory = 'test_directory'
+ test_directory = "test_directory"
if os.path.isdir(test_directory):
os.rmdir(test_directory)
self.sampler = bilby.core.sampler.Sampler(
- likelihood=likelihood, priors=priors,
- outdir=test_directory, use_ratio=False,
- skip_import_verification=True)
+ likelihood=likelihood,
+ priors=priors,
+ outdir=test_directory,
+ use_ratio=False,
+ skip_import_verification=True,
+ )
def tearDown(self):
del self.sampler
def test_search_parameter_keys(self):
- expected_search_parameter_keys = ['c']
- self.assertListEqual(self.sampler.search_parameter_keys, expected_search_parameter_keys)
+ expected_search_parameter_keys = ["c"]
+ self.assertListEqual(
+ self.sampler.search_parameter_keys, expected_search_parameter_keys
+ )
def test_fixed_parameter_keys(self):
- expected_fixed_parameter_keys = ['a']
- self.assertListEqual(self.sampler.fixed_parameter_keys, expected_fixed_parameter_keys)
+ expected_fixed_parameter_keys = ["a"]
+ self.assertListEqual(
+ self.sampler.fixed_parameter_keys, expected_fixed_parameter_keys
+ )
def test_ndim(self):
self.assertEqual(self.sampler.ndim, 1)
@@ -52,20 +58,21 @@ class TestSampler(unittest.TestCase):
self.assertDictEqual(self.sampler.kwargs, {})
def test_label(self):
- self.assertEqual(self.sampler.label, 'label')
+ self.assertEqual(self.sampler.label, "label")
def test_prior_transform_transforms_search_parameter_keys(self):
self.sampler.prior_transform([0])
expected_prior = prior.Uniform(0, 1)
- self.assertListEqual([self.sampler.priors['c'].minimum,
- self.sampler.priors['c'].maximum],
- [expected_prior.minimum,
- expected_prior.maximum])
+ self.assertListEqual(
+ [self.sampler.priors["c"].minimum, self.sampler.priors["c"].maximum],
+ [expected_prior.minimum, expected_prior.maximum],
+ )
def test_prior_transform_does_not_transform_fixed_parameter_keys(self):
self.sampler.prior_transform([0])
- self.assertEqual(self.sampler.priors['a'].peak,
- prior.DeltaFunction(peak=0).peak)
+ self.assertEqual(
+ self.sampler.priors["a"].peak, prior.DeltaFunction(peak=0).peak
+ )
def test_log_prior(self):
self.assertEqual(self.sampler.log_prior({1}), 0.0)
@@ -79,9 +86,7 @@ class TestSampler(unittest.TestCase):
self.assertEqual(self.sampler.log_likelihood([0]), 2)
def test_log_likelihood_correctly_sets_parameters(self):
- expected_dict = dict(a=0,
- b=2,
- c=0)
+ expected_dict = dict(a=0, b=2, c=0)
_ = self.sampler.log_likelihood([0])
self.assertDictEqual(self.sampler.likelihood.parameters, expected_dict)
@@ -95,16 +100,20 @@ class TestSampler(unittest.TestCase):
class TestCPNest(unittest.TestCase):
-
def setUp(self):
self.likelihood = MagicMock()
self.priors = bilby.core.prior.PriorDict(
- dict(a=bilby.core.prior.Uniform(0, 1),
- b=bilby.core.prior.Uniform(0, 1)))
- self.sampler = bilby.core.sampler.Cpnest(self.likelihood, self.priors,
- outdir='outdir', label='label',
- use_ratio=False, plot=False,
- skip_import_verification=True)
+ dict(a=bilby.core.prior.Uniform(0, 1), b=bilby.core.prior.Uniform(0, 1))
+ )
+ self.sampler = bilby.core.sampler.Cpnest(
+ self.likelihood,
+ self.priors,
+ outdir="outdir",
+ label="label",
+ use_ratio=False,
+ plot=False,
+ skip_import_verification=True,
+ )
def tearDown(self):
del self.likelihood
@@ -112,36 +121,58 @@ class TestCPNest(unittest.TestCase):
del self.sampler
def test_default_kwargs(self):
- expected = dict(verbose=3, nthreads=1, nlive=500, maxmcmc=1000,
- seed=None, poolsize=100, nhamiltonian=0, resume=True,
- output='outdir/cpnest_label/', proposals=None,
- n_periodic_checkpoint=8000)
+ expected = dict(
+ verbose=3,
+ nthreads=1,
+ nlive=500,
+ maxmcmc=1000,
+ seed=None,
+ poolsize=100,
+ nhamiltonian=0,
+ resume=True,
+ output="outdir/cpnest_label/",
+ proposals=None,
+ n_periodic_checkpoint=8000,
+ )
self.assertDictEqual(expected, self.sampler.kwargs)
def test_translate_kwargs(self):
- expected = dict(verbose=3, nthreads=1, nlive=250, maxmcmc=1000,
- seed=None, poolsize=100, nhamiltonian=0, resume=True,
- output='outdir/cpnest_label/', proposals=None,
- n_periodic_checkpoint=8000)
+ expected = dict(
+ verbose=3,
+ nthreads=1,
+ nlive=250,
+ maxmcmc=1000,
+ seed=None,
+ poolsize=100,
+ nhamiltonian=0,
+ resume=True,
+ output="outdir/cpnest_label/",
+ proposals=None,
+ n_periodic_checkpoint=8000,
+ )
for equiv in bilby.core.sampler.base_sampler.NestedSampler.npoints_equiv_kwargs:
new_kwargs = self.sampler.kwargs.copy()
- del new_kwargs['nlive']
+ del new_kwargs["nlive"]
new_kwargs[equiv] = 250
self.sampler.kwargs = new_kwargs
self.assertDictEqual(expected, self.sampler.kwargs)
class TestDynesty(unittest.TestCase):
-
def setUp(self):
self.likelihood = MagicMock()
self.priors = bilby.core.prior.PriorDict(
- dict(a=bilby.core.prior.Uniform(0, 1),
- b=bilby.core.prior.Uniform(0, 1)))
- self.sampler = bilby.core.sampler.Dynesty(self.likelihood, self.priors,
- outdir='outdir', label='label',
- use_ratio=False, plot=False,
- skip_import_verification=True)
+ dict(a=bilby.core.prior.Uniform(0, 1), b=bilby.core.prior.Uniform(0, 1))
+ )
+ self.sampler = bilby.core.sampler.Dynesty(
+ self.likelihood,
+ self.priors,
+ outdir="outdir",
+ label="label",
+ use_ratio=False,
+ plot=False,
+ skip_import_verification=True,
+ )
def tearDown(self):
del self.likelihood
@@ -149,57 +180,127 @@ class TestDynesty(unittest.TestCase):
del self.sampler
def test_default_kwargs(self):
- expected = dict(bound='multi', sample='rwalk', periodic=None, reflective=None, verbose=True,
- check_point_delta_t=600, nlive=1000, first_update=None,
- npdim=None, rstate=None, queue_size=1, pool=None,
- use_pool=None, live_points=None, logl_args=None, logl_kwargs=None,
- ptform_args=None, ptform_kwargs=None,
- enlarge=1.5, bootstrap=None, vol_dec=0.5, vol_check=8.0,
- facc=0.2, slices=5, dlogz=0.1, maxiter=None, maxcall=None,
- logl_max=np.inf, add_live=True, print_progress=True, save_bounds=False,
- walks=100, update_interval=600, print_func='func', n_effective=None,
- maxmcmc=5000, nact=5)
- self.sampler.kwargs['print_func'] = 'func' # set this manually as this is not testable otherwise
+ expected = dict(
+ bound="multi",
+ sample="rwalk",
+ periodic=None,
+ reflective=None,
+ verbose=True,
+ check_point_delta_t=600,
+ nlive=1000,
+ first_update=None,
+ npdim=None,
+ rstate=None,
+ queue_size=1,
+ pool=None,
+ use_pool=None,
+ live_points=None,
+ logl_args=None,
+ logl_kwargs=None,
+ ptform_args=None,
+ ptform_kwargs=None,
+ enlarge=1.5,
+ bootstrap=None,
+ vol_dec=0.5,
+ vol_check=8.0,
+ facc=0.2,
+ slices=5,
+ dlogz=0.1,
+ maxiter=None,
+ maxcall=None,
+ logl_max=np.inf,
+ add_live=True,
+ print_progress=True,
+ save_bounds=False,
+ walks=100,
+ update_interval=600,
+ print_func="func",
+ n_effective=None,
+ maxmcmc=5000,
+ nact=5,
+ )
+ self.sampler.kwargs[
+ "print_func"
+ ] = "func" # set this manually as this is not testable otherwise
# DictEqual can't handle lists so we check these separately
- self.assertEqual([], self.sampler.kwargs['periodic'])
- self.assertEqual([], self.sampler.kwargs['reflective'])
- self.sampler.kwargs['periodic'] = expected['periodic']
- self.sampler.kwargs['reflective'] = expected['reflective']
+ self.assertEqual([], self.sampler.kwargs["periodic"])
+ self.assertEqual([], self.sampler.kwargs["reflective"])
+ self.sampler.kwargs["periodic"] = expected["periodic"]
+ self.sampler.kwargs["reflective"] = expected["reflective"]
for key in self.sampler.kwargs.keys():
- print("key={}, expected={}, actual={}"
- .format(key, expected[key], self.sampler.kwargs[key]))
+ print(
+ "key={}, expected={}, actual={}".format(
+ key, expected[key], self.sampler.kwargs[key]
+ )
+ )
self.assertDictEqual(expected, self.sampler.kwargs)
def test_translate_kwargs(self):
- expected = dict(bound='multi', sample='rwalk', periodic=[], reflective=[], verbose=True,
- check_point_delta_t=600, nlive=1000, first_update=None,
- npdim=None, rstate=None, queue_size=1, pool=None,
- use_pool=None, live_points=None, logl_args=None, logl_kwargs=None,
- ptform_args=None, ptform_kwargs=None,
- enlarge=1.5, bootstrap=None, vol_dec=0.5, vol_check=8.0,
- facc=0.2, slices=5, dlogz=0.1, maxiter=None, maxcall=None,
- logl_max=np.inf, add_live=True, print_progress=True, save_bounds=False,
- walks=100, update_interval=600, print_func='func', n_effective=None,
- maxmcmc=5000, nact=5)
+ expected = dict(
+ bound="multi",
+ sample="rwalk",
+ periodic=[],
+ reflective=[],
+ verbose=True,
+ check_point_delta_t=600,
+ nlive=1000,
+ first_update=None,
+ npdim=None,
+ rstate=None,
+ queue_size=1,
+ pool=None,
+ use_pool=None,
+ live_points=None,
+ logl_args=None,
+ logl_kwargs=None,
+ ptform_args=None,
+ ptform_kwargs=None,
+ enlarge=1.5,
+ bootstrap=None,
+ vol_dec=0.5,
+ vol_check=8.0,
+ facc=0.2,
+ slices=5,
+ dlogz=0.1,
+ maxiter=None,
+ maxcall=None,
+ logl_max=np.inf,
+ add_live=True,
+ print_progress=True,
+ save_bounds=False,
+ walks=100,
+ update_interval=600,
+ print_func="func",
+ n_effective=None,
+ maxmcmc=5000,
+ nact=5,
+ )
for equiv in bilby.core.sampler.base_sampler.NestedSampler.npoints_equiv_kwargs:
new_kwargs = self.sampler.kwargs.copy()
- del new_kwargs['nlive']
+ del new_kwargs["nlive"]
new_kwargs[equiv] = 1000
self.sampler.kwargs = new_kwargs
- self.sampler.kwargs['print_func'] = 'func' # set this manually as this is not testable otherwise
+ self.sampler.kwargs[
+ "print_func"
+ ] = "func" # set this manually as this is not testable otherwise
self.assertDictEqual(expected, self.sampler.kwargs)
def test_prior_boundary(self):
- self.priors['a'] = bilby.core.prior.Prior(boundary='periodic')
- self.priors['b'] = bilby.core.prior.Prior(boundary='reflective')
- self.priors['c'] = bilby.core.prior.Prior(boundary=None)
- self.priors['d'] = bilby.core.prior.Prior(boundary='reflective')
- self.priors['e'] = bilby.core.prior.Prior(boundary='periodic')
- self.sampler = bilby.core.sampler.Dynesty(self.likelihood, self.priors,
- outdir='outdir', label='label',
- use_ratio=False, plot=False,
- skip_import_verification=True)
+ self.priors["a"] = bilby.core.prior.Prior(boundary="periodic")
+ self.priors["b"] = bilby.core.prior.Prior(boundary="reflective")
+ self.priors["c"] = bilby.core.prior.Prior(boundary=None)
+ self.priors["d"] = bilby.core.prior.Prior(boundary="reflective")
+ self.priors["e"] = bilby.core.prior.Prior(boundary="periodic")
+ self.sampler = bilby.core.sampler.Dynesty(
+ self.likelihood,
+ self.priors,
+ outdir="outdir",
+ label="label",
+ use_ratio=False,
+ plot=False,
+ skip_import_verification=True,
+ )
self.assertEqual([0, 4], self.sampler.kwargs["periodic"])
self.assertEqual(self.sampler._periodic, self.sampler.kwargs["periodic"])
self.assertEqual([1, 3], self.sampler.kwargs["reflective"])
@@ -207,16 +308,20 @@ class TestDynesty(unittest.TestCase):
class TestEmcee(unittest.TestCase):
-
def setUp(self):
self.likelihood = MagicMock()
self.priors = bilby.core.prior.PriorDict(
- dict(a=bilby.core.prior.Uniform(0, 1),
- b=bilby.core.prior.Uniform(0, 1)))
- self.sampler = bilby.core.sampler.Emcee(self.likelihood, self.priors,
- outdir='outdir', label='label',
- use_ratio=False, plot=False,
- skip_import_verification=True)
+ dict(a=bilby.core.prior.Uniform(0, 1), b=bilby.core.prior.Uniform(0, 1))
+ )
+ self.sampler = bilby.core.sampler.Emcee(
+ self.likelihood,
+ self.priors,
+ outdir="outdir",
+ label="label",
+ use_ratio=False,
+ plot=False,
+ skip_import_verification=True,
+ )
def tearDown(self):
del self.likelihood
@@ -224,37 +329,66 @@ class TestEmcee(unittest.TestCase):
del self.sampler
def test_default_kwargs(self):
- expected = dict(nwalkers=500, a=2, args=[], kwargs={},
- postargs=None, pool=None, live_dangerously=False,
- runtime_sortingfn=None, lnprob0=None, rstate0=None,
- blobs0=None, iterations=100, thin=1, storechain=True, mh_proposal=None
- )
+ expected = dict(
+ nwalkers=500,
+ a=2,
+ args=[],
+ kwargs={},
+ postargs=None,
+ pool=None,
+ live_dangerously=False,
+ runtime_sortingfn=None,
+ lnprob0=None,
+ rstate0=None,
+ blobs0=None,
+ iterations=100,
+ thin=1,
+ storechain=True,
+ mh_proposal=None,
+ )
self.assertDictEqual(expected, self.sampler.kwargs)
def test_translate_kwargs(self):
- expected = dict(nwalkers=100, a=2, args=[], kwargs={},
- postargs=None, pool=None, live_dangerously=False,
- runtime_sortingfn=None, lnprob0=None, rstate0=None,
- blobs0=None, iterations=100, thin=1, storechain=True, mh_proposal=None)
+ expected = dict(
+ nwalkers=100,
+ a=2,
+ args=[],
+ kwargs={},
+ postargs=None,
+ pool=None,
+ live_dangerously=False,
+ runtime_sortingfn=None,
+ lnprob0=None,
+ rstate0=None,
+ blobs0=None,
+ iterations=100,
+ thin=1,
+ storechain=True,
+ mh_proposal=None,
+ )
for equiv in bilby.core.sampler.base_sampler.MCMCSampler.nwalkers_equiv_kwargs:
new_kwargs = self.sampler.kwargs.copy()
- del new_kwargs['nwalkers']
+ del new_kwargs["nwalkers"]
new_kwargs[equiv] = 100
self.sampler.kwargs = new_kwargs
self.assertDictEqual(expected, self.sampler.kwargs)
class TestKombine(unittest.TestCase):
-
def setUp(self):
self.likelihood = MagicMock()
self.priors = bilby.core.prior.PriorDict(
- dict(a=bilby.core.prior.Uniform(0, 1),
- b=bilby.core.prior.Uniform(0, 1)))
- self.sampler = bilby.core.sampler.Kombine(self.likelihood, self.priors,
- outdir='outdir', label='label',
- use_ratio=False, plot=False,
- skip_import_verification=True)
+ dict(a=bilby.core.prior.Uniform(0, 1), b=bilby.core.prior.Uniform(0, 1))
+ )
+ self.sampler = bilby.core.sampler.Kombine(
+ self.likelihood,
+ self.priors,
+ outdir="outdir",
+ label="label",
+ use_ratio=False,
+ plot=False,
+ skip_import_verification=True,
+ )
def tearDown(self):
del self.likelihood
@@ -262,37 +396,73 @@ class TestKombine(unittest.TestCase):
del self.sampler
def test_default_kwargs(self):
- expected = dict(nwalkers=500, args=[], pool=None, transd=False,
- lnpost0=None, blob0=None, iterations=500, storechain=True, processes=1, update_interval=None,
- kde=None, kde_size=None, spaces=None, freeze_transd=False, test_steps=16, critical_pval=0.05,
- max_steps=None, burnin_verbose=False)
+ expected = dict(
+ nwalkers=500,
+ args=[],
+ pool=None,
+ transd=False,
+ lnpost0=None,
+ blob0=None,
+ iterations=500,
+ storechain=True,
+ processes=1,
+ update_interval=None,
+ kde=None,
+ kde_size=None,
+ spaces=None,
+ freeze_transd=False,
+ test_steps=16,
+ critical_pval=0.05,
+ max_steps=None,
+ burnin_verbose=False,
+ )
self.assertDictEqual(expected, self.sampler.kwargs)
def test_translate_kwargs(self):
- expected = dict(nwalkers=400, args=[], pool=None, transd=False,
- lnpost0=None, blob0=None, iterations=500, storechain=True, processes=1, update_interval=None,
- kde=None, kde_size=None, spaces=None, freeze_transd=False, test_steps=16, critical_pval=0.05,
- max_steps=None, burnin_verbose=False)
+ expected = dict(
+ nwalkers=400,
+ args=[],
+ pool=None,
+ transd=False,
+ lnpost0=None,
+ blob0=None,
+ iterations=500,
+ storechain=True,
+ processes=1,
+ update_interval=None,
+ kde=None,
+ kde_size=None,
+ spaces=None,
+ freeze_transd=False,
+ test_steps=16,
+ critical_pval=0.05,
+ max_steps=None,
+ burnin_verbose=False,
+ )
for equiv in bilby.core.sampler.base_sampler.MCMCSampler.nwalkers_equiv_kwargs:
new_kwargs = self.sampler.kwargs.copy()
- del new_kwargs['nwalkers']
+ del new_kwargs["nwalkers"]
new_kwargs[equiv] = 400
self.sampler.kwargs = new_kwargs
self.assertDictEqual(expected, self.sampler.kwargs)
class TestNestle(unittest.TestCase):
-
def setUp(self):
self.likelihood = MagicMock()
self.priors = bilby.core.prior.PriorDict(
- dict(a=bilby.core.prior.Uniform(0, 1),
- b=bilby.core.prior.Uniform(0, 1)))
- self.sampler = bilby.core.sampler.Nestle(self.likelihood, self.priors,
- outdir='outdir', label='label',
- use_ratio=False, plot=False,
- skip_import_verification=True,
- verbose=False)
+ dict(a=bilby.core.prior.Uniform(0, 1), b=bilby.core.prior.Uniform(0, 1))
+ )
+ self.sampler = bilby.core.sampler.Nestle(
+ self.likelihood,
+ self.priors,
+ outdir="outdir",
+ label="label",
+ use_ratio=False,
+ plot=False,
+ skip_import_verification=True,
+ verbose=False,
+ )
def tearDown(self):
del self.likelihood
@@ -300,37 +470,63 @@ class TestNestle(unittest.TestCase):
del self.sampler
def test_default_kwargs(self):
- expected = dict(verbose=False, method='multi', npoints=500,
- update_interval=None, npdim=None, maxiter=None,
- maxcall=None, dlogz=None, decline_factor=None,
- rstate=None, callback=None, steps=20, enlarge=1.2)
+ expected = dict(
+ verbose=False,
+ method="multi",
+ npoints=500,
+ update_interval=None,
+ npdim=None,
+ maxiter=None,
+ maxcall=None,
+ dlogz=None,
+ decline_factor=None,
+ rstate=None,
+ callback=None,
+ steps=20,
+ enlarge=1.2,
+ )
self.assertDictEqual(expected, self.sampler.kwargs)
def test_translate_kwargs(self):
- expected = dict(verbose=False, method='multi', npoints=345,
- update_interval=None, npdim=None, maxiter=None,
- maxcall=None, dlogz=None, decline_factor=None,
- rstate=None, callback=None, steps=20, enlarge=1.2)
- self.sampler.kwargs['npoints'] = 123
+ expected = dict(
+ verbose=False,
+ method="multi",
+ npoints=345,
+ update_interval=None,
+ npdim=None,
+ maxiter=None,
+ maxcall=None,
+ dlogz=None,
+ decline_factor=None,
+ rstate=None,
+ callback=None,
+ steps=20,
+ enlarge=1.2,
+ )
+ self.sampler.kwargs["npoints"] = 123
for equiv in bilby.core.sampler.base_sampler.NestedSampler.npoints_equiv_kwargs:
new_kwargs = self.sampler.kwargs.copy()
- del new_kwargs['npoints']
+ del new_kwargs["npoints"]
new_kwargs[equiv] = 345
self.sampler.kwargs = new_kwargs
self.assertDictEqual(expected, self.sampler.kwargs)
class TestPolyChord(unittest.TestCase):
-
def setUp(self):
self.likelihood = MagicMock()
self.priors = bilby.core.prior.PriorDict(
- dict(a=bilby.core.prior.Uniform(0, 1),
- b=bilby.core.prior.Uniform(0, 1)))
- self.sampler = bilby.core.sampler.PyPolyChord(self.likelihood, self.priors,
- outdir='outdir', label='polychord',
- use_ratio=False, plot=False,
- skip_import_verification=True)
+ dict(a=bilby.core.prior.Uniform(0, 1), b=bilby.core.prior.Uniform(0, 1))
+ )
+ self.sampler = bilby.core.sampler.PyPolyChord(
+ self.likelihood,
+ self.priors,
+ outdir="outdir",
+ label="polychord",
+ use_ratio=False,
+ plot=False,
+ skip_import_verification=True,
+ )
def tearDown(self):
del self.likelihood
@@ -338,48 +534,92 @@ class TestPolyChord(unittest.TestCase):
del self.sampler
def test_default_kwargs(self):
- expected = dict(use_polychord_defaults=False, nlive=self.sampler.ndim*25, num_repeats=self.sampler.ndim*5,
- nprior=-1, do_clustering=True, feedback=1, precision_criterion=0.001,
- logzero=-1e30, max_ndead=-1, boost_posterior=0.0, posteriors=True,
- equals=True, cluster_posteriors=True, write_resume=True,
- write_paramnames=False, read_resume=True, write_stats=True,
- write_live=True, write_dead=True, write_prior=True,
- compression_factor=np.exp(-1), base_dir='outdir',
- file_root='polychord', seed=-1, grade_dims=list([self.sampler.ndim]),
- grade_frac=list([1.0]*len([self.sampler.ndim])), nlives={})
+ expected = dict(
+ use_polychord_defaults=False,
+ nlive=self.sampler.ndim * 25,
+ num_repeats=self.sampler.ndim * 5,
+ nprior=-1,
+ do_clustering=True,
+ feedback=1,
+ precision_criterion=0.001,
+ logzero=-1e30,
+ max_ndead=-1,
+ boost_posterior=0.0,
+ posteriors=True,
+ equals=True,
+ cluster_posteriors=True,
+ write_resume=True,
+ write_paramnames=False,
+ read_resume=True,
+ write_stats=True,
+ write_live=True,
+ write_dead=True,
+ write_prior=True,
+ compression_factor=np.exp(-1),
+ base_dir="outdir",
+ file_root="polychord",
+ seed=-1,
+ grade_dims=list([self.sampler.ndim]),
+ grade_frac=list([1.0] * len([self.sampler.ndim])),
+ nlives={},
+ )
self.sampler._setup_dynamic_defaults()
self.assertDictEqual(expected, self.sampler.kwargs)
def test_translate_kwargs(self):
- expected = dict(use_polychord_defaults=False, nlive=123, num_repeats=self.sampler.ndim*5,
- nprior=-1, do_clustering=True, feedback=1, precision_criterion=0.001,
- logzero=-1e30, max_ndead=-1, boost_posterior=0.0, posteriors=True,
- equals=True, cluster_posteriors=True, write_resume=True,
- write_paramnames=False, read_resume=True, write_stats=True,
- write_live=True, write_dead=True, write_prior=True,
- compression_factor=np.exp(-1), base_dir='outdir',
- file_root='polychord', seed=-1, grade_dims=list([self.sampler.ndim]),
- grade_frac=list([1.0]*len([self.sampler.ndim])), nlives={})
+ expected = dict(
+ use_polychord_defaults=False,
+ nlive=123,
+ num_repeats=self.sampler.ndim * 5,
+ nprior=-1,
+ do_clustering=True,
+ feedback=1,
+ precision_criterion=0.001,
+ logzero=-1e30,
+ max_ndead=-1,
+ boost_posterior=0.0,
+ posteriors=True,
+ equals=True,
+ cluster_posteriors=True,
+ write_resume=True,
+ write_paramnames=False,
+ read_resume=True,
+ write_stats=True,
+ write_live=True,
+ write_dead=True,
+ write_prior=True,
+ compression_factor=np.exp(-1),
+ base_dir="outdir",
+ file_root="polychord",
+ seed=-1,
+ grade_dims=list([self.sampler.ndim]),
+ grade_frac=list([1.0] * len([self.sampler.ndim])),
+ nlives={},
+ )
self.sampler._setup_dynamic_defaults()
for equiv in bilby.core.sampler.base_sampler.NestedSampler.npoints_equiv_kwargs:
new_kwargs = self.sampler.kwargs.copy()
- del new_kwargs['nlive']
+ del new_kwargs["nlive"]
new_kwargs[equiv] = 123
self.sampler.kwargs = new_kwargs
self.assertDictEqual(expected, self.sampler.kwargs)
class TestPTEmcee(unittest.TestCase):
-
def setUp(self):
self.likelihood = MagicMock()
self.priors = bilby.core.prior.PriorDict(
- dict(a=bilby.core.prior.Uniform(0, 1),
- b=bilby.core.prior.Uniform(0, 1)))
- self.sampler = bilby.core.sampler.Ptemcee(self.likelihood, self.priors,
- outdir='outdir', label='label',
- use_ratio=False, plot=False,
- skip_import_verification=True)
+ dict(a=bilby.core.prior.Uniform(0, 1), b=bilby.core.prior.Uniform(0, 1))
+ )
+ self.sampler = bilby.core.sampler.Ptemcee(
+ self.likelihood,
+ self.priors,
+ outdir="outdir",
+ label="label",
+ use_ratio=False,
+ plot=False,
+ skip_import_verification=True,
+ )
def tearDown(self):
del self.likelihood
@@ -387,34 +627,56 @@ class TestPTEmcee(unittest.TestCase):
del self.sampler
def test_default_kwargs(self):
- expected = dict(ntemps=20, nwalkers=200, Tmax=None, betas=None, a=2.0,
- adaptation_lag=10000, adaptation_time=100, random=None,
- adapt=True, swap_ratios=False,)
+ expected = dict(
+ ntemps=20,
+ nwalkers=200,
+ Tmax=None,
+ betas=None,
+ a=2.0,
+ adaptation_lag=10000,
+ adaptation_time=100,
+ random=None,
+ adapt=True,
+ swap_ratios=False,
+ )
self.assertDictEqual(expected, self.sampler.kwargs)
def test_translate_kwargs(self):
- expected = dict(ntemps=20, nwalkers=200, Tmax=None, betas=None, a=2.0,
- adaptation_lag=10000, adaptation_time=100, random=None,
- adapt=True, swap_ratios=False,)
+ expected = dict(
+ ntemps=20,
+ nwalkers=200,
+ Tmax=None,
+ betas=None,
+ a=2.0,
+ adaptation_lag=10000,
+ adaptation_time=100,
+ random=None,
+ adapt=True,
+ swap_ratios=False,
+ )
for equiv in bilby.core.sampler.base_sampler.MCMCSampler.nwalkers_equiv_kwargs:
new_kwargs = self.sampler.kwargs.copy()
- del new_kwargs['nwalkers']
+ del new_kwargs["nwalkers"]
new_kwargs[equiv] = 200
self.sampler.kwargs = new_kwargs
self.assertDictEqual(expected, self.sampler.kwargs)
class TestPyMC3(unittest.TestCase):
-
def setUp(self):
self.likelihood = MagicMock()
self.priors = bilby.core.prior.PriorDict(
- dict(a=bilby.core.prior.Uniform(0, 1),
- b=bilby.core.prior.Uniform(0, 1)))
- self.sampler = bilby.core.sampler.Pymc3(self.likelihood, self.priors,
- outdir='outdir', label='label',
- use_ratio=False, plot=False,
- skip_import_verification=True)
+ dict(a=bilby.core.prior.Uniform(0, 1), b=bilby.core.prior.Uniform(0, 1))
+ )
+ self.sampler = bilby.core.sampler.Pymc3(
+ self.likelihood,
+ self.priors,
+ outdir="outdir",
+ label="label",
+ use_ratio=False,
+ plot=False,
+ skip_import_verification=True,
+ )
def tearDown(self):
del self.likelihood
@@ -423,40 +685,72 @@ class TestPyMC3(unittest.TestCase):
def test_default_kwargs(self):
expected = dict(
- draws=500, step=None, init='auto', n_init=200000, start=None, trace=None, chain_idx=0,
- chains=2, cores=1, tune=500, nuts_kwargs=None, step_kwargs=None, progressbar=True,
- model=None, random_seed=None, discard_tuned_samples=True,
- compute_convergence_checks=True)
+ draws=500,
+ step=None,
+ init="auto",
+ n_init=200000,
+ start=None,
+ trace=None,
+ chain_idx=0,
+ chains=2,
+ cores=1,
+ tune=500,
+ nuts_kwargs=None,
+ step_kwargs=None,
+ progressbar=True,
+ model=None,
+ random_seed=None,
+ discard_tuned_samples=True,
+ compute_convergence_checks=True,
+ )
self.assertDictEqual(expected, self.sampler.kwargs)
def test_translate_kwargs(self):
expected = dict(
- draws=500, step=None, init='auto', n_init=200000, start=None, trace=None, chain_idx=0,
- chains=2, cores=1, tune=500, nuts_kwargs=None, step_kwargs=None, progressbar=True,
- model=None, random_seed=None, discard_tuned_samples=True,
- compute_convergence_checks=True)
- self.sampler.kwargs['draws'] = 123
+ draws=500,
+ step=None,
+ init="auto",
+ n_init=200000,
+ start=None,
+ trace=None,
+ chain_idx=0,
+ chains=2,
+ cores=1,
+ tune=500,
+ nuts_kwargs=None,
+ step_kwargs=None,
+ progressbar=True,
+ model=None,
+ random_seed=None,
+ discard_tuned_samples=True,
+ compute_convergence_checks=True,
+ )
+ self.sampler.kwargs["draws"] = 123
for equiv in bilby.core.sampler.base_sampler.NestedSampler.npoints_equiv_kwargs:
new_kwargs = self.sampler.kwargs.copy()
- del new_kwargs['draws']
+ del new_kwargs["draws"]
new_kwargs[equiv] = 500
self.sampler.kwargs = new_kwargs
self.assertDictEqual(expected, self.sampler.kwargs)
class TestPymultinest(unittest.TestCase):
-
def setUp(self):
self.likelihood = MagicMock()
self.priors = bilby.core.prior.PriorDict(
- dict(a=bilby.core.prior.Uniform(0, 1),
- b=bilby.core.prior.Uniform(0, 1)))
- self.priors['a'] = bilby.core.prior.Prior(boundary='periodic')
- self.priors['b'] = bilby.core.prior.Prior(boundary='reflective')
- self.sampler = bilby.core.sampler.Pymultinest(self.likelihood, self.priors,
- outdir='outdir', label='label',
- use_ratio=False, plot=False,
- skip_import_verification=True)
+ dict(a=bilby.core.prior.Uniform(0, 1), b=bilby.core.prior.Uniform(0, 1))
+ )
+ self.priors["a"] = bilby.core.prior.Prior(boundary="periodic")
+ self.priors["b"] = bilby.core.prior.Prior(boundary="reflective")
+ self.sampler = bilby.core.sampler.Pymultinest(
+ self.likelihood,
+ self.priors,
+ outdir="outdir",
+ label="label",
+ use_ratio=False,
+ plot=False,
+ skip_import_verification=True,
+ )
def tearDown(self):
del self.likelihood
@@ -489,17 +783,19 @@ class TestPymultinest(unittest.TestCase):
max_modes=100, mode_tolerance=-1e90, seed=-1,
context=0, write_output=True, log_zero=-1e100,
max_iter=0, init_MPI=False, dump_callback=None)
+
for equiv in bilby.core.sampler.base_sampler.NestedSampler.npoints_equiv_kwargs:
new_kwargs = self.sampler.kwargs.copy()
- del new_kwargs['n_live_points']
- new_kwargs['wrapped_params'] = None # The dict comparison can't handle lists
+ del new_kwargs["n_live_points"]
+ new_kwargs[
+ "wrapped_params"
+ ] = None # The dict comparison can't handle lists
new_kwargs[equiv] = 123
self.sampler.kwargs = new_kwargs
self.assertDictEqual(expected, self.sampler.kwargs)
class TestRunningSamplers(unittest.TestCase):
-
def setUp(self):
np.random.seed(42)
bilby.core.utils.command_line_args.bilby_test_mode = False
@@ -507,80 +803,140 @@ class TestRunningSamplers(unittest.TestCase):
self.model = lambda x, m, c: m * x + c
self.injection_parameters = dict(m=0.5, c=0.2)
self.sigma = 0.1
- self.y = self.model(self.x, **self.injection_parameters) +\
- np.random.normal(0, self.sigma, len(self.x))
+ self.y = self.model(self.x, **self.injection_parameters) + np.random.normal(
+ 0, self.sigma, len(self.x)
+ )
self.likelihood = bilby.likelihood.GaussianLikelihood(
- self.x, self.y, self.model, self.sigma)
+ self.x, self.y, self.model, self.sigma
+ )
self.priors = bilby.core.prior.PriorDict()
- self.priors['m'] = bilby.core.prior.Uniform(0, 5, boundary='reflective')
- self.priors['c'] = bilby.core.prior.Uniform(-2, 2, boundary='reflective')
- bilby.core.utils.check_directory_exists_and_if_not_mkdir('outdir')
+ self.priors["m"] = bilby.core.prior.Uniform(0, 5, boundary="reflective")
+ self.priors["c"] = bilby.core.prior.Uniform(-2, 2, boundary="reflective")
+ bilby.core.utils.check_directory_exists_and_if_not_mkdir("outdir")
def tearDown(self):
del self.likelihood
del self.priors
bilby.core.utils.command_line_args.bilby_test_mode = False
- shutil.rmtree('outdir')
+ shutil.rmtree("outdir")
def test_run_cpnest(self):
_ = bilby.run_sampler(
- likelihood=self.likelihood, priors=self.priors, sampler='cpnest',
- nlive=100, save=False, resume=False)
+ likelihood=self.likelihood,
+ priors=self.priors,
+ sampler="cpnest",
+ nlive=100,
+ save=False,
+ resume=False,
+ )
def test_run_dynesty(self):
_ = bilby.run_sampler(
- likelihood=self.likelihood, priors=self.priors, sampler='dynesty',
- nlive=100, save=False)
+ likelihood=self.likelihood,
+ priors=self.priors,
+ sampler="dynesty",
+ nlive=100,
+ save=False,
+ )
def test_run_dynamic_dynesty(self):
_ = bilby.run_sampler(
- likelihood=self.likelihood, priors=self.priors, sampler='dynamic_dynesty',
- nlive_init=100, nlive_batch=100, dlogz_init=1.0, maxbatch=0,
- maxcall=100, bound="single", save=False)
+ likelihood=self.likelihood,
+ priors=self.priors,
+ sampler="dynamic_dynesty",
+ nlive_init=100,
+ nlive_batch=100,
+ dlogz_init=1.0,
+ maxbatch=0,
+ maxcall=100,
+ bound="single",
+ save=False,
+ )
def test_run_emcee(self):
_ = bilby.run_sampler(
- likelihood=self.likelihood, priors=self.priors, sampler='emcee',
- iterations=1000, nwalkers=10, save=False)
+ likelihood=self.likelihood,
+ priors=self.priors,
+ sampler="emcee",
+ iterations=1000,
+ nwalkers=10,
+ save=False,
+ )
def test_run_kombine(self):
_ = bilby.run_sampler(
- likelihood=self.likelihood, priors=self.priors, sampler='kombine',
- iterations=1000, nwalkers=100, save=False, autoburnin=True)
+ likelihood=self.likelihood,
+ priors=self.priors,
+ sampler="kombine",
+ iterations=1000,
+ nwalkers=100,
+ save=False,
+ autoburnin=True,
+ )
def test_run_nestle(self):
_ = bilby.run_sampler(
- likelihood=self.likelihood, priors=self.priors, sampler='nestle',
- nlive=100, save=False)
+ likelihood=self.likelihood,
+ priors=self.priors,
+ sampler="nestle",
+ nlive=100,
+ save=False,
+ )
def test_run_pypolychord(self):
_ = bilby.run_sampler(
- likelihood=self.likelihood, priors=self.priors,
- sampler='pypolychord', nlive=100, save=False)
+ likelihood=self.likelihood,
+ priors=self.priors,
+ sampler="pypolychord",
+ nlive=100,
+ save=False,
+ )
def test_run_ptemcee(self):
_ = bilby.run_sampler(
- likelihood=self.likelihood, priors=self.priors, sampler='ptemcee',
- nsamples=100, nwalkers=50, burn_in_act=1, ntemps=1,
- frac_threshold=0.5, save=False)
+ likelihood=self.likelihood,
+ priors=self.priors,
+ sampler="ptemcee",
+ nsamples=100,
+ nwalkers=50,
+ burn_in_act=1,
+ ntemps=1,
+ frac_threshold=0.5,
+ save=False,
+ )
def test_run_pymc3(self):
_ = bilby.run_sampler(
- likelihood=self.likelihood, priors=self.priors, sampler='pymc3',
- draws=50, tune=50, n_init=1000, save=False)
+ likelihood=self.likelihood,
+ priors=self.priors,
+ sampler="pymc3",
+ draws=50,
+ tune=50,
+ n_init=1000,
+ save=False,
+ )
def test_run_pymultinest(self):
_ = bilby.run_sampler(
- likelihood=self.likelihood, priors=self.priors,
- sampler='pymultinest', nlive=100, save=False)
+ likelihood=self.likelihood,
+ priors=self.priors,
+ sampler="pymultinest",
+ nlive=100,
+ save=False,
+ )
def test_run_PTMCMCSampler(self):
_ = bilby.run_sampler(
- likelihood=self.likelihood, priors=self.priors,
- sampler='PTMCMCsampler', Niter=101, burn=2,
- isave=100, save=False)
+ likelihood=self.likelihood,
+ priors=self.priors,
+ sampler="PTMCMCsampler",
+ Niter=101,
+ burn=2,
+ isave=100,
+ save=False,
+ )
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/series_test.py b/test/series_test.py
index 1eeec8cafbba747220bd731f09c166ee43085165..97849a13f4eb86dbcc9874aad85c0f1fae451b76 100644
--- a/test/series_test.py
+++ b/test/series_test.py
@@ -7,14 +7,15 @@ from bilby.core.series import CoupledTimeAndFrequencySeries
class TestCoupledTimeAndFrequencySeries(unittest.TestCase):
-
def setUp(self):
self.duration = 2
self.sampling_frequency = 4096
self.start_time = -1
self.series = CoupledTimeAndFrequencySeries(
- duration=self.duration, sampling_frequency=self.sampling_frequency,
- start_time=self.start_time)
+ duration=self.duration,
+ sampling_frequency=self.sampling_frequency,
+ start_time=self.start_time,
+ )
def tearDown(self):
del self.duration
@@ -23,19 +24,21 @@ class TestCoupledTimeAndFrequencySeries(unittest.TestCase):
del self.series
def test_repr(self):
- expected =\
- 'CoupledTimeAndFrequencySeries(duration={}, sampling_frequency={},'\
- ' start_time={})'.format(
- self.series.duration, self.series.sampling_frequency,
- self.series.start_time)
+ expected = (
+ "CoupledTimeAndFrequencySeries(duration={}, sampling_frequency={},"
+ " start_time={})".format(
+ self.series.duration,
+ self.series.sampling_frequency,
+ self.series.start_time,
+ )
+ )
self.assertEqual(expected, repr(self.series))
def test_duration_from_init(self):
self.assertEqual(self.duration, self.series.duration)
def test_sampling_from_init(self):
- self.assertEqual(
- self.sampling_frequency, self.series.sampling_frequency)
+ self.assertEqual(self.sampling_frequency, self.series.sampling_frequency)
def test_start_time_from_init(self):
self.assertEqual(self.start_time, self.series.start_time)
@@ -48,25 +51,31 @@ class TestCoupledTimeAndFrequencySeries(unittest.TestCase):
def test_frequency_array_from_init(self):
expected = create_frequency_series(
- sampling_frequency=self.sampling_frequency, duration=self.duration)
+ sampling_frequency=self.sampling_frequency, duration=self.duration
+ )
self.assertTrue(np.array_equal(expected, self.series.frequency_array))
def test_time_array_from_init(self):
expected = create_time_series(
- sampling_frequency=self.sampling_frequency, duration=self.duration,
- starting_time=self.start_time)
+ sampling_frequency=self.sampling_frequency,
+ duration=self.duration,
+ starting_time=self.start_time,
+ )
self.assertTrue(np.array_equal(expected, self.series.time_array))
def test_frequency_array_setter(self):
new_sampling_frequency = 100
new_duration = 3
new_frequency_array = create_frequency_series(
- sampling_frequency=new_sampling_frequency, duration=new_duration)
+ sampling_frequency=new_sampling_frequency, duration=new_duration
+ )
self.series.frequency_array = new_frequency_array
- self.assertTrue(np.array_equal(
- new_frequency_array, self.series.frequency_array))
- self.assertLessEqual(np.abs(
- new_sampling_frequency - self.series.sampling_frequency), 1)
+ self.assertTrue(
+ np.array_equal(new_frequency_array, self.series.frequency_array)
+ )
+ self.assertLessEqual(
+ np.abs(new_sampling_frequency - self.series.sampling_frequency), 1
+ )
self.assertAlmostEqual(new_duration, self.series.duration)
self.assertAlmostEqual(self.start_time, self.series.start_time)
@@ -75,12 +84,15 @@ class TestCoupledTimeAndFrequencySeries(unittest.TestCase):
new_duration = 3
new_start_time = 4
new_time_array = create_time_series(
- sampling_frequency=new_sampling_frequency, duration=new_duration,
- starting_time=new_start_time)
+ sampling_frequency=new_sampling_frequency,
+ duration=new_duration,
+ starting_time=new_start_time,
+ )
self.series.time_array = new_time_array
self.assertTrue(np.array_equal(new_time_array, self.series.time_array))
self.assertAlmostEqual(
- new_sampling_frequency, self.series.sampling_frequency, places=1)
+ new_sampling_frequency, self.series.sampling_frequency, places=1
+ )
self.assertAlmostEqual(new_duration, self.series.duration, places=1)
self.assertAlmostEqual(new_start_time, self.series.start_time, places=1)
@@ -109,5 +121,5 @@ class TestCoupledTimeAndFrequencySeries(unittest.TestCase):
_ = self.series.frequency_array
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/utils_py3_test.py b/test/utils_py3_test.py
index 99af2d39cf069a00917f545f9cd326cc2506c8e5..fa0717bef6214576f0ec99c8652fda33acc7cc41 100644
--- a/test/utils_py3_test.py
+++ b/test/utils_py3_test.py
@@ -6,7 +6,6 @@ from bilby.core import utils
class TestInferParameters(unittest.TestCase):
-
def setUp(self):
def source_function1(freqs, a, b: int):
return None
@@ -40,26 +39,26 @@ class TestInferParameters(unittest.TestCase):
del self.source4
def test_type_hinting(self):
- expected = ['a', 'b']
+ expected = ["a", "b"]
actual = utils.infer_parameters_from_function(self.source1)
self.assertListEqual(expected, actual)
def test_args_kwargs_handling(self):
- expected = ['a', 'b']
+ expected = ["a", "b"]
actual = utils.infer_parameters_from_function(self.source2)
self.assertListEqual(expected, actual)
def test_both(self):
- expected = ['a', 'b']
+ expected = ["a", "b"]
actual = utils.infer_parameters_from_function(self.source3)
self.assertListEqual(expected, actual)
def test_self_handling(self):
- expected = ['a', 'b']
+ expected = ["a", "b"]
actual = utils.infer_args_from_method(self.source4)
self.assertListEqual(expected, actual)
def test_self_handling_method_as_function(self):
- expected = ['a', 'b']
+ expected = ["a", "b"]
actual = utils.infer_args_from_method(self.source5)
self.assertListEqual(expected, actual)
diff --git a/test/utils_test.py b/test/utils_test.py
index 6245683de36eaa3bcd161e6a475c4a081434b973..49911364661375bd479aa6ddf703016721df9501 100644
--- a/test/utils_test.py
+++ b/test/utils_test.py
@@ -10,34 +10,32 @@ from bilby.core import utils
class TestConstants(unittest.TestCase):
-
def test_speed_of_light(self):
self.assertEqual(utils.speed_of_light, lal.C_SI)
self.assertLess(
- abs(utils.speed_of_light - constants.c.value) / utils.speed_of_light,
- 1e-16)
+ abs(utils.speed_of_light - constants.c.value) / utils.speed_of_light, 1e-16
+ )
def test_parsec(self):
self.assertEqual(utils.parsec, lal.PC_SI)
- self.assertLess(
- abs(utils.parsec - constants.pc.value) / utils.parsec,
- 1e-11)
+ self.assertLess(abs(utils.parsec - constants.pc.value) / utils.parsec, 1e-11)
def test_solar_mass(self):
self.assertEqual(utils.solar_mass, lal.MSUN_SI)
self.assertLess(
- abs(utils.solar_mass - constants.M_sun.value) / utils.solar_mass,
- 1e-4)
+ abs(utils.solar_mass - constants.M_sun.value) / utils.solar_mass, 1e-4
+ )
def test_radius_of_earth(self):
self.assertEqual(bilby.core.utils.radius_of_earth, lal.REARTH_SI)
self.assertLess(
- abs(utils.radius_of_earth - constants.R_earth.value) / utils.radius_of_earth,
- 1e-5)
+ abs(utils.radius_of_earth - constants.R_earth.value)
+ / utils.radius_of_earth,
+ 1e-5,
+ )
class TestFFT(unittest.TestCase):
-
def setUp(self):
self.sampling_frequency = 10
@@ -51,19 +49,24 @@ class TestFFT(unittest.TestCase):
time_domain_strain = np.sin(2 * np.pi * times * injected_frequency + 0.4)
- frequency_domain_strain, frequencies = bilby.core.utils.nfft(time_domain_strain, self.sampling_frequency)
+ frequency_domain_strain, frequencies = bilby.core.utils.nfft(
+ time_domain_strain, self.sampling_frequency
+ )
frequency_at_peak = frequencies[np.argmax(np.abs(frequency_domain_strain))]
self.assertAlmostEqual(injected_frequency, frequency_at_peak, places=1)
def test_nfft_infft(self):
time_domain_strain = np.random.normal(0, 1, 10)
- frequency_domain_strain, _ = bilby.core.utils.nfft(time_domain_strain, self.sampling_frequency)
- new_time_domain_strain = bilby.core.utils.infft(frequency_domain_strain, self.sampling_frequency)
+ frequency_domain_strain, _ = bilby.core.utils.nfft(
+ time_domain_strain, self.sampling_frequency
+ )
+ new_time_domain_strain = bilby.core.utils.infft(
+ frequency_domain_strain, self.sampling_frequency
+ )
self.assertTrue(np.allclose(time_domain_strain, new_time_domain_strain))
class TestInferParameters(unittest.TestCase):
-
def setUp(self):
def source_function(freqs, a, b, *args, **kwargs):
return None
@@ -86,33 +89,35 @@ class TestInferParameters(unittest.TestCase):
del self.source1
del self.source2
-
def test_args_kwargs_handling(self):
- expected = ['a', 'b']
+ expected = ["a", "b"]
actual = utils.infer_parameters_from_function(self.source1)
self.assertListEqual(expected, actual)
def test_self_handling(self):
- expected = ['a', 'b']
+ expected = ["a", "b"]
actual = utils.infer_args_from_method(self.source2)
self.assertListEqual(expected, actual)
-
+
def test_self_handling_method_as_function(self):
- expected = ['a', 'b']
+ expected = ["a", "b"]
actual = utils.infer_parameters_from_function(self.source3)
self.assertListEqual(expected, actual)
-class TestTimeAndFrequencyArrays(unittest.TestCase):
+class TestTimeAndFrequencyArrays(unittest.TestCase):
def setUp(self):
self.start_time = 1.3
self.sampling_frequency = 5
self.duration = 1.6
- self.frequency_array = utils.create_frequency_series(sampling_frequency=self.sampling_frequency,
- duration=self.duration)
- self.time_array = utils.create_time_series(sampling_frequency=self.sampling_frequency,
- duration=self.duration,
- starting_time=self.start_time)
+ self.frequency_array = utils.create_frequency_series(
+ sampling_frequency=self.sampling_frequency, duration=self.duration
+ )
+ self.time_array = utils.create_time_series(
+ sampling_frequency=self.sampling_frequency,
+ duration=self.duration,
+ starting_time=self.start_time,
+ )
def tearDown(self):
del self.start_time
@@ -123,28 +128,38 @@ class TestTimeAndFrequencyArrays(unittest.TestCase):
def test_create_time_array(self):
expected_time_array = np.array([1.3, 1.5, 1.7, 1.9, 2.1, 2.3, 2.5, 2.7])
- time_array = utils.create_time_series(sampling_frequency=self.sampling_frequency,
- duration=self.duration, starting_time=self.start_time)
+ time_array = utils.create_time_series(
+ sampling_frequency=self.sampling_frequency,
+ duration=self.duration,
+ starting_time=self.start_time,
+ )
self.assertTrue(np.allclose(expected_time_array, time_array))
def test_create_frequency_array(self):
expected_frequency_array = np.array([0.0, 0.625, 1.25, 1.875, 2.5])
- frequency_array = utils.create_frequency_series(sampling_frequency=self.sampling_frequency,
- duration=self.duration)
+ frequency_array = utils.create_frequency_series(
+ sampling_frequency=self.sampling_frequency, duration=self.duration
+ )
self.assertTrue(np.allclose(expected_frequency_array, frequency_array))
def test_get_sampling_frequency_from_time_array(self):
- new_sampling_freq, _ = utils.get_sampling_frequency_and_duration_from_time_array(
- self.time_array)
+ (
+ new_sampling_freq,
+ _,
+ ) = utils.get_sampling_frequency_and_duration_from_time_array(self.time_array)
self.assertEqual(self.sampling_frequency, new_sampling_freq)
def test_get_sampling_frequency_from_time_array_unequally_sampled(self):
self.time_array[-1] += 0.0001
with self.assertRaises(ValueError):
- _, _ = utils.get_sampling_frequency_and_duration_from_time_array(self.time_array)
+ _, _ = utils.get_sampling_frequency_and_duration_from_time_array(
+ self.time_array
+ )
def test_get_duration_from_time_array(self):
- _, new_duration = utils.get_sampling_frequency_and_duration_from_time_array(self.time_array)
+ _, new_duration = utils.get_sampling_frequency_and_duration_from_time_array(
+ self.time_array
+ )
self.assertEqual(self.duration, new_duration)
def test_get_start_time_from_time_array(self):
@@ -152,74 +167,88 @@ class TestTimeAndFrequencyArrays(unittest.TestCase):
self.assertEqual(self.start_time, new_start_time)
def test_get_sampling_frequency_from_frequency_array(self):
- new_sampling_freq, _ = utils.get_sampling_frequency_and_duration_from_frequency_array(
- self.frequency_array)
+ (
+ new_sampling_freq,
+ _,
+ ) = utils.get_sampling_frequency_and_duration_from_frequency_array(
+ self.frequency_array
+ )
self.assertEqual(self.sampling_frequency, new_sampling_freq)
def test_get_sampling_frequency_from_frequency_array_unequally_sampled(self):
self.frequency_array[-1] += 0.0001
with self.assertRaises(ValueError):
- _, _ = utils.get_sampling_frequency_and_duration_from_frequency_array(self.frequency_array)
+ _, _ = utils.get_sampling_frequency_and_duration_from_frequency_array(
+ self.frequency_array
+ )
def test_get_duration_from_frequency_array(self):
- _, new_duration = utils.get_sampling_frequency_and_duration_from_frequency_array(
- self.frequency_array)
+ (
+ _,
+ new_duration,
+ ) = utils.get_sampling_frequency_and_duration_from_frequency_array(
+ self.frequency_array
+ )
self.assertEqual(self.duration, new_duration)
def test_consistency_time_array_to_time_array(self):
- new_sampling_frequency, new_duration = \
- utils.get_sampling_frequency_and_duration_from_time_array(self.time_array)
+ (
+ new_sampling_frequency,
+ new_duration,
+ ) = utils.get_sampling_frequency_and_duration_from_time_array(self.time_array)
new_start_time = self.time_array[0]
- new_time_array = utils.create_time_series(sampling_frequency=new_sampling_frequency,
- duration=new_duration,
- starting_time=new_start_time)
+ new_time_array = utils.create_time_series(
+ sampling_frequency=new_sampling_frequency,
+ duration=new_duration,
+ starting_time=new_start_time,
+ )
self.assertTrue(np.allclose(self.time_array, new_time_array))
def test_consistency_frequency_array_to_frequency_array(self):
- new_sampling_frequency, new_duration = utils.get_sampling_frequency_and_duration_from_frequency_array(self.frequency_array)
- new_frequency_array = \
- utils.create_frequency_series(sampling_frequency=new_sampling_frequency,
- duration=new_duration)
+ (
+ new_sampling_frequency,
+ new_duration,
+ ) = utils.get_sampling_frequency_and_duration_from_frequency_array(
+ self.frequency_array
+ )
+ new_frequency_array = utils.create_frequency_series(
+ sampling_frequency=new_sampling_frequency, duration=new_duration
+ )
self.assertTrue(np.allclose(self.frequency_array, new_frequency_array))
def test_illegal_sampling_frequency_and_duration(self):
with self.assertRaises(utils.IllegalDurationAndSamplingFrequencyException):
- _ = utils.create_time_series(sampling_frequency=7.7,
- duration=1.3,
- starting_time=0)
+ _ = utils.create_time_series(
+ sampling_frequency=7.7, duration=1.3, starting_time=0
+ )
class TestReflect(unittest.TestCase):
-
def test_in_range(self):
xprime = np.array([0.1, 0.5, 0.9])
x = np.array([0.1, 0.5, 0.9])
- self.assertTrue(
- np.testing.assert_allclose(utils.reflect(xprime), x) is None)
+ self.assertTrue(np.testing.assert_allclose(utils.reflect(xprime), x) is None)
def test_in_one_to_two(self):
xprime = np.array([1.1, 1.5, 1.9])
x = np.array([0.9, 0.5, 0.1])
- self.assertTrue(
- np.testing.assert_allclose(utils.reflect(xprime), x) is None)
+ self.assertTrue(np.testing.assert_allclose(utils.reflect(xprime), x) is None)
def test_in_two_to_three(self):
xprime = np.array([2.1, 2.5, 2.9])
x = np.array([0.1, 0.5, 0.9])
- self.assertTrue(
- np.testing.assert_allclose(utils.reflect(xprime), x) is None)
+ self.assertTrue(np.testing.assert_allclose(utils.reflect(xprime), x) is None)
def test_in_minus_one_to_zero(self):
xprime = np.array([-0.9, -0.5, -0.1])
x = np.array([0.9, 0.5, 0.1])
- self.assertTrue(
- np.testing.assert_allclose(utils.reflect(xprime), x) is None)
+ self.assertTrue(np.testing.assert_allclose(utils.reflect(xprime), x) is None)
def test_in_minus_two_to_minus_one(self):
xprime = np.array([-1.9, -1.5, -1.1])
x = np.array([0.1, 0.5, 0.9])
- self.assertTrue(
- np.testing.assert_allclose(utils.reflect(xprime), x) is None)
+ self.assertTrue(np.testing.assert_allclose(utils.reflect(xprime), x) is None)
+
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/waveform_generator_test.py b/test/waveform_generator_test.py
index 86d433ccd94be3f37e214655c7aced5ba4c9ccd2..69e3112c07ea995492689fdca5ee40c83a64a0f1 100644
--- a/test/waveform_generator_test.py
+++ b/test/waveform_generator_test.py
@@ -8,64 +8,94 @@ import lal
import lalsimulation as lalsim
-def dummy_func_array_return_value(frequency_array, amplitude, mu, sigma, ra, dec, geocent_time, psi, **kwargs):
+def dummy_func_array_return_value(
+ frequency_array, amplitude, mu, sigma, ra, dec, geocent_time, psi, **kwargs
+):
return amplitude + mu + frequency_array + sigma + ra + dec + geocent_time + psi
-def dummy_func_dict_return_value(frequency_array, amplitude, mu, sigma, ra, dec, geocent_time, psi, **kwargs):
- ht = {'plus': amplitude + mu + frequency_array + sigma + ra + dec + geocent_time + psi,
- 'cross': amplitude + mu + frequency_array + sigma + ra + dec + geocent_time + psi}
+def dummy_func_dict_return_value(
+ frequency_array, amplitude, mu, sigma, ra, dec, geocent_time, psi, **kwargs
+):
+ ht = {
+ "plus": amplitude
+ + mu
+ + frequency_array
+ + sigma
+ + ra
+ + dec
+ + geocent_time
+ + psi,
+ "cross": amplitude
+ + mu
+ + frequency_array
+ + sigma
+ + ra
+ + dec
+ + geocent_time
+ + psi,
+ }
return ht
-def dummy_func_array_return_value_2(array, amplitude, mu, sigma, ra, dec, geocent_time, psi):
+def dummy_func_array_return_value_2(
+ array, amplitude, mu, sigma, ra, dec, geocent_time, psi
+):
return dict(plus=np.array(array), cross=np.array(array))
class TestWaveformGeneratorInstantiationWithoutOptionalParameters(unittest.TestCase):
-
def setUp(self):
- self.waveform_generator = \
- bilby.gw.waveform_generator.WaveformGenerator(
- 1, 4096,
- frequency_domain_source_model=dummy_func_dict_return_value)
- self.simulation_parameters = dict(amplitude=1e-21, mu=100, sigma=1,
- ra=1.375,
- dec=-1.2108,
- geocent_time=1126259642.413,
- psi=2.659)
+ self.waveform_generator = bilby.gw.waveform_generator.WaveformGenerator(
+ 1, 4096, frequency_domain_source_model=dummy_func_dict_return_value
+ )
+ self.simulation_parameters = dict(
+ amplitude=1e-21,
+ mu=100,
+ sigma=1,
+ ra=1.375,
+ dec=-1.2108,
+ geocent_time=1126259642.413,
+ psi=2.659,
+ )
def tearDown(self):
del self.waveform_generator
del self.simulation_parameters
def test_repr(self):
- expected = 'WaveformGenerator(duration={}, sampling_frequency={}, start_time={}, ' \
- 'frequency_domain_source_model={}, time_domain_source_model={}, ' \
- 'parameter_conversion={}, waveform_arguments={})'\
- .format(self.waveform_generator.duration,
- self.waveform_generator.sampling_frequency,
- self.waveform_generator.start_time,
- self.waveform_generator.frequency_domain_source_model.__name__,
- self.waveform_generator.time_domain_source_model,
- None,
- self.waveform_generator.waveform_arguments)
+ expected = (
+ "WaveformGenerator(duration={}, sampling_frequency={}, start_time={}, "
+ "frequency_domain_source_model={}, time_domain_source_model={}, "
+ "parameter_conversion={}, waveform_arguments={})".format(
+ self.waveform_generator.duration,
+ self.waveform_generator.sampling_frequency,
+ self.waveform_generator.start_time,
+ self.waveform_generator.frequency_domain_source_model.__name__,
+ self.waveform_generator.time_domain_source_model,
+ None,
+ self.waveform_generator.waveform_arguments,
+ )
+ )
self.assertEqual(expected, repr(self.waveform_generator))
def test_repr_with_time_domain_source_model(self):
- self.waveform_generator = \
- bilby.gw.waveform_generator.WaveformGenerator(1, 4096,
- time_domain_source_model=dummy_func_dict_return_value)
- expected = 'WaveformGenerator(duration={}, sampling_frequency={}, start_time={}, ' \
- 'frequency_domain_source_model={}, time_domain_source_model={}, ' \
- 'parameter_conversion={}, waveform_arguments={})'\
- .format(self.waveform_generator.duration,
- self.waveform_generator.sampling_frequency,
- self.waveform_generator.start_time,
- self.waveform_generator.frequency_domain_source_model,
- self.waveform_generator.time_domain_source_model.__name__,
- None,
- self.waveform_generator.waveform_arguments)
+ self.waveform_generator = bilby.gw.waveform_generator.WaveformGenerator(
+ 1, 4096, time_domain_source_model=dummy_func_dict_return_value
+ )
+ expected = (
+ "WaveformGenerator(duration={}, sampling_frequency={}, start_time={}, "
+ "frequency_domain_source_model={}, time_domain_source_model={}, "
+ "parameter_conversion={}, waveform_arguments={})".format(
+ self.waveform_generator.duration,
+ self.waveform_generator.sampling_frequency,
+ self.waveform_generator.start_time,
+ self.waveform_generator.frequency_domain_source_model,
+ self.waveform_generator.time_domain_source_model.__name__,
+ None,
+ self.waveform_generator.waveform_arguments,
+ )
+ )
self.assertEqual(expected, repr(self.waveform_generator))
def test_repr_with_param_conversion(self):
@@ -73,16 +103,19 @@ class TestWaveformGeneratorInstantiationWithoutOptionalParameters(unittest.TestC
pass
self.waveform_generator.parameter_conversion = conversion_func
- expected = 'WaveformGenerator(duration={}, sampling_frequency={}, start_time={}, ' \
- 'frequency_domain_source_model={}, time_domain_source_model={}, ' \
- 'parameter_conversion={}, waveform_arguments={})'\
- .format(self.waveform_generator.duration,
- self.waveform_generator.sampling_frequency,
- self.waveform_generator.start_time,
- self.waveform_generator.frequency_domain_source_model.__name__,
- self.waveform_generator.time_domain_source_model,
- conversion_func.__name__,
- self.waveform_generator.waveform_arguments)
+ expected = (
+ "WaveformGenerator(duration={}, sampling_frequency={}, start_time={}, "
+ "frequency_domain_source_model={}, time_domain_source_model={}, "
+ "parameter_conversion={}, waveform_arguments={})".format(
+ self.waveform_generator.duration,
+ self.waveform_generator.sampling_frequency,
+ self.waveform_generator.start_time,
+ self.waveform_generator.frequency_domain_source_model.__name__,
+ self.waveform_generator.time_domain_source_model,
+ conversion_func.__name__,
+ self.waveform_generator.waveform_arguments,
+ )
+ )
self.assertEqual(expected, repr(self.waveform_generator))
def test_duration(self):
@@ -92,7 +125,10 @@ class TestWaveformGeneratorInstantiationWithoutOptionalParameters(unittest.TestC
self.assertEqual(self.waveform_generator.sampling_frequency, 4096)
def test_source_model(self):
- self.assertEqual(self.waveform_generator.frequency_domain_source_model, dummy_func_dict_return_value)
+ self.assertEqual(
+ self.waveform_generator.frequency_domain_source_model,
+ dummy_func_dict_return_value,
+ )
def test_frequency_array_type(self):
self.assertIsInstance(self.waveform_generator.frequency_array, np.ndarray)
@@ -102,36 +138,45 @@ class TestWaveformGeneratorInstantiationWithoutOptionalParameters(unittest.TestC
def test_source_model_parameters(self):
self.waveform_generator.parameters = self.simulation_parameters.copy()
- self.assertListEqual(sorted(list(self.waveform_generator.parameters.keys())),
- sorted(list(self.simulation_parameters.keys())))
+ self.assertListEqual(
+ sorted(list(self.waveform_generator.parameters.keys())),
+ sorted(list(self.simulation_parameters.keys())),
+ )
class TestWaveformArgumentsSetting(unittest.TestCase):
def setUp(self):
- self.waveform_generator = \
- bilby.gw.waveform_generator.WaveformGenerator(1, 4096,
- frequency_domain_source_model=dummy_func_dict_return_value,
- waveform_arguments=dict(test='test', arguments='arguments'))
+ self.waveform_generator = bilby.gw.waveform_generator.WaveformGenerator(
+ 1,
+ 4096,
+ frequency_domain_source_model=dummy_func_dict_return_value,
+ waveform_arguments=dict(test="test", arguments="arguments"),
+ )
def tearDown(self):
del self.waveform_generator
def test_waveform_arguments_init_setting(self):
- self.assertDictEqual(self.waveform_generator.waveform_arguments,
- dict(test='test', arguments='arguments'))
+ self.assertDictEqual(
+ self.waveform_generator.waveform_arguments,
+ dict(test="test", arguments="arguments"),
+ )
class TestSetters(unittest.TestCase):
-
def setUp(self):
- self.waveform_generator = \
- bilby.gw.waveform_generator.WaveformGenerator(1, 4096,
- frequency_domain_source_model=dummy_func_dict_return_value)
- self.simulation_parameters = dict(amplitude=1e-21, mu=100, sigma=1,
- ra=1.375,
- dec=-1.2108,
- geocent_time=1126259642.413,
- psi=2.659)
+ self.waveform_generator = bilby.gw.waveform_generator.WaveformGenerator(
+ 1, 4096, frequency_domain_source_model=dummy_func_dict_return_value
+ )
+ self.simulation_parameters = dict(
+ amplitude=1e-21,
+ mu=100,
+ sigma=1,
+ ra=1.375,
+ dec=-1.2108,
+ geocent_time=1126259642.413,
+ psi=2.659,
+ )
def tearDown(self):
del self.waveform_generator
@@ -140,7 +185,9 @@ class TestSetters(unittest.TestCase):
def test_parameter_setter_sets_expected_values_with_expected_keys(self):
self.waveform_generator.parameters = self.simulation_parameters.copy()
for key in self.simulation_parameters:
- self.assertEqual(self.waveform_generator.parameters[key], self.simulation_parameters[key])
+ self.assertEqual(
+ self.waveform_generator.parameters[key], self.simulation_parameters[key]
+ )
def test_parameter_setter_none_handling(self):
with self.assertRaises(TypeError):
@@ -151,71 +198,94 @@ class TestSetters(unittest.TestCase):
def test_frequency_array_setter(self):
new_frequency_array = np.arange(1, 100)
self.waveform_generator.frequency_array = new_frequency_array
- self.assertTrue(np.array_equal(new_frequency_array, self.waveform_generator.frequency_array))
+ self.assertTrue(
+ np.array_equal(new_frequency_array, self.waveform_generator.frequency_array)
+ )
def test_time_array_setter(self):
new_time_array = np.arange(1, 100)
self.waveform_generator.time_array = new_time_array
- self.assertTrue(np.array_equal(new_time_array, self.waveform_generator.time_array))
+ self.assertTrue(
+ np.array_equal(new_time_array, self.waveform_generator.time_array)
+ )
def test_parameters_set_from_frequency_domain_source_model(self):
- self.waveform_generator.frequency_domain_source_model = dummy_func_dict_return_value
+ self.waveform_generator.frequency_domain_source_model = (
+ dummy_func_dict_return_value
+ )
self.waveform_generator.parameters = self.simulation_parameters.copy()
- self.assertListEqual(sorted(list(self.waveform_generator.parameters.keys())),
- sorted(list(self.simulation_parameters.keys())))
+ self.assertListEqual(
+ sorted(list(self.waveform_generator.parameters.keys())),
+ sorted(list(self.simulation_parameters.keys())),
+ )
def test_parameters_set_from_time_domain_source_model(self):
self.waveform_generator.time_domain_source_model = dummy_func_dict_return_value
self.waveform_generator.parameters = self.simulation_parameters.copy()
- self.assertListEqual(sorted(list(self.waveform_generator.parameters.keys())),
- sorted(list(self.simulation_parameters.keys())))
+ self.assertListEqual(
+ sorted(list(self.waveform_generator.parameters.keys())),
+ sorted(list(self.simulation_parameters.keys())),
+ )
def test_set_parameter_conversion_at_init(self):
def conversion_func():
pass
- self.waveform_generator = \
- bilby.gw.waveform_generator.WaveformGenerator(1, 4096,
- frequency_domain_source_model=dummy_func_dict_return_value,
- parameter_conversion=conversion_func)
+ self.waveform_generator = bilby.gw.waveform_generator.WaveformGenerator(
+ 1,
+ 4096,
+ frequency_domain_source_model=dummy_func_dict_return_value,
+ parameter_conversion=conversion_func,
+ )
self.assertEqual(conversion_func, self.waveform_generator.parameter_conversion)
class TestFrequencyDomainStrainMethod(unittest.TestCase):
-
def setUp(self):
- self.waveform_generator = \
- bilby.gw.waveform_generator.WaveformGenerator(duration=1, sampling_frequency=4096,
- frequency_domain_source_model=dummy_func_dict_return_value)
- self.simulation_parameters = dict(amplitude=1e-2, mu=100, sigma=1,
- ra=1.375,
- dec=-1.2108,
- geocent_time=1126259642.413,
- psi=2.659)
+ self.waveform_generator = bilby.gw.waveform_generator.WaveformGenerator(
+ duration=1,
+ sampling_frequency=4096,
+ frequency_domain_source_model=dummy_func_dict_return_value,
+ )
+ self.simulation_parameters = dict(
+ amplitude=1e-2,
+ mu=100,
+ sigma=1,
+ ra=1.375,
+ dec=-1.2108,
+ geocent_time=1126259642.413,
+ psi=2.659,
+ )
def tearDown(self):
del self.waveform_generator
del self.simulation_parameters
def test_parameter_conversion_is_called(self):
- self.waveform_generator.parameter_conversion = MagicMock(side_effect=KeyError('test'))
+ self.waveform_generator.parameter_conversion = MagicMock(
+ side_effect=KeyError("test")
+ )
with self.assertRaises(KeyError):
self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
def test_frequency_domain_source_model_call(self):
- expected = self.waveform_generator.frequency_domain_source_model(self.waveform_generator.frequency_array,
- self.simulation_parameters['amplitude'],
- self.simulation_parameters['mu'],
- self.simulation_parameters['sigma'],
- self.simulation_parameters['ra'],
- self.simulation_parameters['dec'],
- self.simulation_parameters['geocent_time'],
- self.simulation_parameters['psi'])
+ expected = self.waveform_generator.frequency_domain_source_model(
+ self.waveform_generator.frequency_array,
+ self.simulation_parameters["amplitude"],
+ self.simulation_parameters["mu"],
+ self.simulation_parameters["sigma"],
+ self.simulation_parameters["ra"],
+ self.simulation_parameters["dec"],
+ self.simulation_parameters["geocent_time"],
+ self.simulation_parameters["psi"],
+ )
actual = self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
- self.assertTrue(np.array_equal(expected['plus'], actual['plus']))
- self.assertTrue(np.array_equal(expected['cross'], actual['cross']))
+ parameters=self.simulation_parameters
+ )
+ self.assertTrue(np.array_equal(expected["plus"], actual["plus"]))
+ self.assertTrue(np.array_equal(expected["cross"], actual["cross"]))
def test_time_domain_source_model_call_with_ndarray(self):
self.waveform_generator.frequency_domain_source_model = None
@@ -224,12 +294,14 @@ class TestFrequencyDomainStrainMethod(unittest.TestCase):
def side_effect(value, value2):
return value
- with mock.patch('bilby.core.utils.nfft') as m:
+ with mock.patch("bilby.core.utils.nfft") as m:
m.side_effect = side_effect
expected = self.waveform_generator.time_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
actual = self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
self.assertTrue(np.array_equal(expected, actual))
def test_time_domain_source_model_call_with_dict(self):
@@ -239,227 +311,321 @@ class TestFrequencyDomainStrainMethod(unittest.TestCase):
def side_effect(value, value2):
return value, self.waveform_generator.frequency_array
- with mock.patch('bilby.core.utils.nfft') as m:
+ with mock.patch("bilby.core.utils.nfft") as m:
m.side_effect = side_effect
expected = self.waveform_generator.time_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
actual = self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
- self.assertTrue(np.array_equal(expected['plus'], actual['plus']))
- self.assertTrue(np.array_equal(expected['cross'], actual['cross']))
+ parameters=self.simulation_parameters
+ )
+ self.assertTrue(np.array_equal(expected["plus"], actual["plus"]))
+ self.assertTrue(np.array_equal(expected["cross"], actual["cross"]))
def test_no_source_model_given(self):
self.waveform_generator.time_domain_source_model = None
self.waveform_generator.frequency_domain_source_model = None
with self.assertRaises(RuntimeError):
self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
def test_key_popping(self):
- self.waveform_generator.parameter_conversion = MagicMock(return_value=(dict(amplitude=1e-21, mu=100, sigma=1,
- ra=1.375, dec=-1.2108,
- geocent_time=1126259642.413,
- psi=2.659, c=None, d=None),
- ['c', 'd']))
+ self.waveform_generator.parameter_conversion = MagicMock(
+ return_value=(
+ dict(
+ amplitude=1e-21,
+ mu=100,
+ sigma=1,
+ ra=1.375,
+ dec=-1.2108,
+ geocent_time=1126259642.413,
+ psi=2.659,
+ c=None,
+ d=None,
+ ),
+ ["c", "d"],
+ )
+ )
try:
self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
except RuntimeError:
pass
- self.assertListEqual(sorted(self.waveform_generator.parameters.keys()),
- sorted(['amplitude', 'mu', 'sigma', 'ra', 'dec', 'geocent_time', 'psi']))
+ self.assertListEqual(
+ sorted(self.waveform_generator.parameters.keys()),
+ sorted(["amplitude", "mu", "sigma", "ra", "dec", "geocent_time", "psi"]),
+ )
def test_caching_with_parameters(self):
original_waveform = self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
new_waveform = self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
self.assertDictEqual(original_waveform, new_waveform)
def test_caching_without_parameters(self):
original_waveform = self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
new_waveform = self.waveform_generator.frequency_domain_strain()
self.assertDictEqual(original_waveform, new_waveform)
- def test_frequency_domain_caching_and_using_time_domain_strain_without_parameters(self):
+ def test_frequency_domain_caching_and_using_time_domain_strain_without_parameters(
+ self,
+ ):
original_waveform = self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
new_waveform = self.waveform_generator.time_domain_strain()
self.assertNotEqual(original_waveform, new_waveform)
- def test_frequency_domain_caching_and_using_time_domain_strain_with_parameters(self):
+ def test_frequency_domain_caching_and_using_time_domain_strain_with_parameters(
+ self,
+ ):
original_waveform = self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
new_waveform = self.waveform_generator.time_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
self.assertNotEqual(original_waveform, new_waveform)
- def test_time_domain_caching_and_using_frequency_domain_strain_without_parameters(self):
+ def test_time_domain_caching_and_using_frequency_domain_strain_without_parameters(
+ self,
+ ):
original_waveform = self.waveform_generator.time_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
new_waveform = self.waveform_generator.frequency_domain_strain()
self.assertNotEqual(original_waveform, new_waveform)
- def test_time_domain_caching_and_using_frequency_domain_strain_with_parameters(self):
+ def test_time_domain_caching_and_using_frequency_domain_strain_with_parameters(
+ self,
+ ):
original_waveform = self.waveform_generator.time_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
new_waveform = self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
self.assertNotEqual(original_waveform, new_waveform)
def test_frequency_domain_caching_changing_model(self):
original_waveform = self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
- self.waveform_generator.frequency_domain_source_model = dummy_func_array_return_value_2
+ parameters=self.simulation_parameters
+ )
+ self.waveform_generator.frequency_domain_source_model = (
+ dummy_func_array_return_value_2
+ )
new_waveform = self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
- self.assertFalse(np.array_equal(original_waveform['plus'], new_waveform['plus']))
+ parameters=self.simulation_parameters
+ )
+ self.assertFalse(
+ np.array_equal(original_waveform["plus"], new_waveform["plus"])
+ )
def test_time_domain_caching_changing_model(self):
- self.waveform_generator = \
- bilby.gw.waveform_generator.WaveformGenerator(duration=1, sampling_frequency=4096,
- time_domain_source_model=dummy_func_dict_return_value)
+ self.waveform_generator = bilby.gw.waveform_generator.WaveformGenerator(
+ duration=1,
+ sampling_frequency=4096,
+ time_domain_source_model=dummy_func_dict_return_value,
+ )
original_waveform = self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
- self.waveform_generator.time_domain_source_model = dummy_func_array_return_value_2
+ parameters=self.simulation_parameters
+ )
+ self.waveform_generator.time_domain_source_model = (
+ dummy_func_array_return_value_2
+ )
new_waveform = self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
- self.assertFalse(np.array_equal(original_waveform['plus'], new_waveform['plus']))
+ parameters=self.simulation_parameters
+ )
+ self.assertFalse(
+ np.array_equal(original_waveform["plus"], new_waveform["plus"])
+ )
class TestTimeDomainStrainMethod(unittest.TestCase):
-
def setUp(self):
- self.waveform_generator = \
- bilby.gw.waveform_generator.WaveformGenerator(1, 4096,
- time_domain_source_model=dummy_func_dict_return_value)
- self.simulation_parameters = dict(amplitude=1e-21, mu=100, sigma=1,
- ra=1.375,
- dec=-1.2108,
- geocent_time=1126259642.413,
- psi=2.659)
+ self.waveform_generator = bilby.gw.waveform_generator.WaveformGenerator(
+ 1, 4096, time_domain_source_model=dummy_func_dict_return_value
+ )
+ self.simulation_parameters = dict(
+ amplitude=1e-21,
+ mu=100,
+ sigma=1,
+ ra=1.375,
+ dec=-1.2108,
+ geocent_time=1126259642.413,
+ psi=2.659,
+ )
def tearDown(self):
del self.waveform_generator
del self.simulation_parameters
def test_parameter_conversion_is_called(self):
- self.waveform_generator.parameter_conversion = MagicMock(side_effect=KeyError('test'))
+ self.waveform_generator.parameter_conversion = MagicMock(
+ side_effect=KeyError("test")
+ )
with self.assertRaises(KeyError):
self.waveform_generator.time_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
def test_time_domain_source_model_call(self):
- expected = self.waveform_generator.time_domain_source_model(self.waveform_generator.time_array,
- self.simulation_parameters['amplitude'],
- self.simulation_parameters['mu'],
- self.simulation_parameters['sigma'],
- self.simulation_parameters['ra'],
- self.simulation_parameters['dec'],
- self.simulation_parameters['geocent_time'],
- self.simulation_parameters['psi'])
+ expected = self.waveform_generator.time_domain_source_model(
+ self.waveform_generator.time_array,
+ self.simulation_parameters["amplitude"],
+ self.simulation_parameters["mu"],
+ self.simulation_parameters["sigma"],
+ self.simulation_parameters["ra"],
+ self.simulation_parameters["dec"],
+ self.simulation_parameters["geocent_time"],
+ self.simulation_parameters["psi"],
+ )
actual = self.waveform_generator.time_domain_strain(
- parameters=self.simulation_parameters)
- self.assertTrue(np.array_equal(expected['plus'], actual['plus']))
- self.assertTrue(np.array_equal(expected['cross'], actual['cross']))
+ parameters=self.simulation_parameters
+ )
+ self.assertTrue(np.array_equal(expected["plus"], actual["plus"]))
+ self.assertTrue(np.array_equal(expected["cross"], actual["cross"]))
def test_frequency_domain_source_model_call_with_ndarray(self):
self.waveform_generator.time_domain_source_model = None
- self.waveform_generator.frequency_domain_source_model = dummy_func_array_return_value
+ self.waveform_generator.frequency_domain_source_model = (
+ dummy_func_array_return_value
+ )
def side_effect(value, value2):
return value
- with mock.patch('bilby.core.utils.infft') as m:
+ with mock.patch("bilby.core.utils.infft") as m:
m.side_effect = side_effect
expected = self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
actual = self.waveform_generator.time_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
self.assertTrue(np.array_equal(expected, actual))
def test_frequency_domain_source_model_call_with_dict(self):
self.waveform_generator.time_domain_source_model = None
- self.waveform_generator.frequency_domain_source_model = dummy_func_dict_return_value
+ self.waveform_generator.frequency_domain_source_model = (
+ dummy_func_dict_return_value
+ )
def side_effect(value, value2):
return value
- with mock.patch('bilby.core.utils.infft') as m:
+ with mock.patch("bilby.core.utils.infft") as m:
m.side_effect = side_effect
expected = self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
actual = self.waveform_generator.time_domain_strain(
- parameters=self.simulation_parameters)
- self.assertTrue(np.array_equal(expected['plus'], actual['plus']))
- self.assertTrue(np.array_equal(expected['cross'], actual['cross']))
+ parameters=self.simulation_parameters
+ )
+ self.assertTrue(np.array_equal(expected["plus"], actual["plus"]))
+ self.assertTrue(np.array_equal(expected["cross"], actual["cross"]))
def test_no_source_model_given(self):
self.waveform_generator.time_domain_source_model = None
self.waveform_generator.frequency_domain_source_model = None
with self.assertRaises(RuntimeError):
self.waveform_generator.time_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
def test_key_popping(self):
- self.waveform_generator.parameter_conversion = MagicMock(return_value=(dict(amplitude=1e-2,
- mu=100,
- sigma=1,
- ra=1.375, dec=-1.2108,
- geocent_time=1126259642.413,
- psi=2.659, c=None, d=None),
- ['c', 'd']))
+ self.waveform_generator.parameter_conversion = MagicMock(
+ return_value=(
+ dict(
+ amplitude=1e-2,
+ mu=100,
+ sigma=1,
+ ra=1.375,
+ dec=-1.2108,
+ geocent_time=1126259642.413,
+ psi=2.659,
+ c=None,
+ d=None,
+ ),
+ ["c", "d"],
+ )
+ )
try:
self.waveform_generator.time_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
except RuntimeError:
pass
- self.assertListEqual(sorted(self.waveform_generator.parameters.keys()),
- sorted(['amplitude', 'mu', 'sigma', 'ra', 'dec', 'geocent_time', 'psi']))
+ self.assertListEqual(
+ sorted(self.waveform_generator.parameters.keys()),
+ sorted(["amplitude", "mu", "sigma", "ra", "dec", "geocent_time", "psi"]),
+ )
def test_caching_with_parameters(self):
original_waveform = self.waveform_generator.time_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
new_waveform = self.waveform_generator.time_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
self.assertDictEqual(original_waveform, new_waveform)
def test_caching_without_parameters(self):
original_waveform = self.waveform_generator.time_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
new_waveform = self.waveform_generator.time_domain_strain()
self.assertDictEqual(original_waveform, new_waveform)
- def test_frequency_domain_caching_and_using_time_domain_strain_without_parameters(self):
+ def test_frequency_domain_caching_and_using_time_domain_strain_without_parameters(
+ self,
+ ):
original_waveform = self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
new_waveform = self.waveform_generator.time_domain_strain()
self.assertNotEqual(original_waveform, new_waveform)
- def test_frequency_domain_caching_and_using_time_domain_strain_with_parameters(self):
+ def test_frequency_domain_caching_and_using_time_domain_strain_with_parameters(
+ self,
+ ):
original_waveform = self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
new_waveform = self.waveform_generator.time_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
self.assertNotEqual(original_waveform, new_waveform)
- def test_time_domain_caching_and_using_frequency_domain_strain_without_parameters(self):
+ def test_time_domain_caching_and_using_frequency_domain_strain_without_parameters(
+ self,
+ ):
original_waveform = self.waveform_generator.time_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
new_waveform = self.waveform_generator.frequency_domain_strain()
self.assertNotEqual(original_waveform, new_waveform)
- def test_time_domain_caching_and_using_frequency_domain_strain_with_parameters(self):
+ def test_time_domain_caching_and_using_frequency_domain_strain_with_parameters(
+ self,
+ ):
original_waveform = self.waveform_generator.time_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
new_waveform = self.waveform_generator.frequency_domain_strain(
- parameters=self.simulation_parameters)
+ parameters=self.simulation_parameters
+ )
self.assertNotEqual(original_waveform, new_waveform)
class TestWaveformDirectAgainstLALSIM(unittest.TestCase):
-
def setUp(self):
self.BBH_precessing_injection_parameters = dict(
mass_1=36.0,
@@ -570,7 +736,9 @@ class TestWaveformDirectAgainstLALSIM(unittest.TestCase):
waveform_arguments=waveform_arguments,
)
- bilby_strain = waveform_generator.frequency_domain_strain(parameters=injection_parameters)
+ bilby_strain = waveform_generator.frequency_domain_strain(
+ parameters=injection_parameters
+ )
# LALSIM Waveform
@@ -600,7 +768,9 @@ class TestWaveformDirectAgainstLALSIM(unittest.TestCase):
h_cross = get_lalsim_waveform["cross"]
if waveform_approximant == "TaylorF2":
- upper_freq = ISCO(injection_parameters["mass_1"], injection_parameters["mass_2"])
+ upper_freq = ISCO(
+ injection_parameters["mass_1"], injection_parameters["mass_2"]
+ )
else:
upper_freq = waveform_generator.frequency_array[-1]
@@ -679,8 +849,22 @@ def ISCO(m1, m2):
def lalsim_FD_waveform(
- m1, m2, s1x, s1y, s1z, s2x, s2y, s2z, theta_jn, phase, duration, dL, fmax,
- lambda_1=None, lambda_2=None, **kwarg
+ m1,
+ m2,
+ s1x,
+ s1y,
+ s1z,
+ s2x,
+ s2y,
+ s2z,
+ theta_jn,
+ phase,
+ duration,
+ dL,
+ fmax,
+ lambda_1=None,
+ lambda_2=None,
+ **kwarg
):
mass1 = m1 * lal.MSUN_SI
mass2 = m2 * lal.MSUN_SI
@@ -709,10 +893,12 @@ def lalsim_FD_waveform(
if lambda_1 is not None:
lalsim.SimInspiralWaveformParamsInsertTidalLambda1(
- waveform_dictionary, float(lambda_1))
+ waveform_dictionary, float(lambda_1)
+ )
if lambda_2 is not None:
lalsim.SimInspiralWaveformParamsInsertTidalLambda2(
- waveform_dictionary, float(lambda_2))
+ waveform_dictionary, float(lambda_2)
+ )
hplus, hcross = lalsim.SimInspiralChooseFDWaveform(
mass1,
@@ -768,7 +954,7 @@ def get_lalsim_psd_list():
and not name.endswith(PSD_suffix)
):
# if name in blacklist:
- name = name[len(PSD_prefix):]
+ name = name[len(PSD_prefix) :]
if (
name not in blacklist
and not name.startswith("iLIGO")
@@ -826,5 +1012,5 @@ def normalize_strain(
return np.sqrt(integral).real
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()