test/gw/detector/interferometer_test.py

 import sys
 import unittest
+
+import lal
+import lalsimulation
 import pytest
 from packaging import version
 from shutil import rmtree
@@ -552,5 +555,46 @@ class TestInterferometerEquals(unittest.TestCase):
         self.assertNotEqual(self.ifo_1, self.ifo_2)
 
 
+class TestInterferometerAntennaPatternAgainstLAL(unittest.TestCase):
+    def setUp(self):
+        self.name = "name"
+        self.ifo_names = ['H1', 'L1', 'V1', 'K1', 'GEO600', 'ET']
+        self.lal_prefixes = {'H1': 'H1', 'L1': 'L1', 'V1': 'V1', 'K1': 'K1', 'GEO600': 'G1', 'ET': 'E1'}
+        self.polarizations = ['plus', 'cross', 'breathing', 'longitudinal', 'x', 'y']
+        self.ifos = bilby.gw.detector.InterferometerList(self.ifo_names)
+        self.gpstime = 1305303144
+        self.trial = 100
+
+    def tearDown(self):
+        del self.name
+        del self.ifo_names
+        del self.lal_prefixes
+        del self.polarizations
+        del self.ifos
+        del self.gpstime
+        del self.trial
+
+    def test_antenna_pattern_vs_lal(self):
+        gmst = lal.GreenwichMeanSiderealTime(self.gpstime)
+        f_bilby = np.zeros((self.trial, 6))
+        f_lal = np.zeros((self.trial, 6))
+
+        for n, ifo_name in enumerate(self.ifo_names):
+            response = lalsimulation.DetectorPrefixToLALDetector(self.lal_prefixes[ifo_name]).response
+            ifo = self.ifos[n]
+            for i in range(self.trial):
+                ra = 2. * np.pi * np.random.uniform()
+                dec = np.pi * np.random.uniform() - np.pi / 2.
+                psi = np.pi * np.random.uniform()
+                f_lal[i] = lal.ComputeDetAMResponseExtraModes(response, ra, dec, psi, gmst)
+                for m, pol in enumerate(self.polarizations):
+                    f_bilby[i, m] = ifo.antenna_response(ra, dec, self.gpstime, psi, pol)
+
+            std = np.std(f_bilby - f_lal, axis=0)
+            for m, pol in enumerate(self.polarizations):
+                with self.subTest(':'.join((ifo_name, pol))):
+                    self.assertAlmostEqual(std[m], 0.0, places=7)
+
+
 if __name__ == "__main__":
     unittest.main()

test/gw/detector/networks_test.py

@@ -3,6 +3,7 @@ import unittest
 import pytest
 from shutil import rmtree
 from packaging import version
+from itertools import combinations
 
 import deepdish as dd
 import mock
@@ -119,7 +120,7 @@ class TestInterferometerList(unittest.TestCase):
             bilby.gw.detector.InterferometerList("string")
 
     def test_init_with_string_list(self):
-        """ Merely checks if this ends up in the right bracket """
+        """Merely checks if this ends up in the right bracket"""
         with mock.patch("bilby.gw.detector.networks.get_empty_interferometer") as m:
             m.side_effect = TypeError
             with self.assertRaises(TypeError):
@@ -240,8 +241,12 @@ class TestInterferometerList(unittest.TestCase):
 
     @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.ifo_list.inject_signal(
+            injection_polarizations=dict(plus=1), raise_error=False
+        )
+        m.assert_called_with(
+            parameters=None, injection_polarizations=dict(plus=1), raise_error=False
+        )
         self.assertEqual(len(self.ifo_list), m.call_count)
 
     @patch.object(bilby.gw.detector.Interferometer, "inject_signal")
@@ -337,7 +342,9 @@ class TestInterferometerList(unittest.TestCase):
             recovered_ifo = bilby.gw.detector.InterferometerList.from_hdf5(filename)
             self.assertListEqual(self.ifo_list, recovered_ifo)
 
-    @pytest.mark.skipif(pandas_version_test or sys.version_info[0] < 3, reason=skip_reason)
+    @pytest.mark.skipif(
+        pandas_version_test or sys.version_info[0] < 3, reason=skip_reason
+    )
     def test_to_and_from_hdf5_wrong_class(self):
         dd.io.save("./outdir/psd.h5", self.ifo_list[0].power_spectral_density)
         filename = self.ifo_list._filename_from_outdir_label_extension(
@@ -354,6 +361,7 @@ class TestInterferometerList(unittest.TestCase):
 
     def test_to_and_from_pkl_wrong_class(self):
         import dill
+
         with open("./outdir/psd.pkl", "wb") as ff:
             dill.dump(self.ifo_list[0].power_spectral_density, ff)
         filename = self.ifo_list._filename_from_outdir_label_extension(
@@ -372,5 +380,40 @@ class TestInterferometerList(unittest.TestCase):
         ifos.plot_data(outdir=self.outdir)
 
 
+class TriangularInterferometerTest(unittest.TestCase):
+    def setUp(self):
+        self.triangular_ifo = bilby.gw.detector.get_empty_interferometer("ET")
+
+    def tearDown(self):
+        del self.triangular_ifo
+
+    def test_individual_positions(self):
+        """
+        Check that the distances between the vertices of the three
+        individual interferometers is approximately equal to the
+        length of the arms of the detector.
+        Calculation following:
+        https://www.movable-type.co.uk/scripts/latlong.html
+        Angles must be in radians
+        """
+
+        def a(delta_lat, delta_long, lat_1, lat_2):
+            return (
+                np.sin(delta_lat / 2) ** 2
+                + np.cos(lat_1) * np.cos(lat_2) * np.sin(delta_long / 2) ** 2
+            )
+
+        def c(a):
+            return 2 * np.arctan2(np.sqrt(a), np.sqrt(1 - a))
+
+        for pair in list(combinations(self.triangular_ifo, 2)):
+            delta_lat = np.radians(pair[1].latitude - pair[0].latitude)
+            delta_long = np.radians(pair[1].longitude - pair[0].longitude)
+            pair_a = a(delta_lat, delta_long, pair[0].latitude, pair[1].latitude)
+            pair_c = c(pair_a)
+            distance = bilby.core.utils.radius_of_earth * pair_c
+            self.assertAlmostEqual(distance / 1000, pair[0].length, delta=1)
+
+
 if __name__ == "__main__":
     unittest.main()

test/gw/utils_test.py

@@ -103,21 +103,13 @@ class TestGWUtils(unittest.TestCase):
     def test_get_event_time(self):
         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)
+        with self.assertRaises(ValueError):
+            gwutils.get_event_time("GW010290")
 
     def test_read_frame_file(self):
         start_time = 0

test/integration/sampler_run_test.py

@@ -25,8 +25,19 @@ class TestRunningSamplers(unittest.TestCase):
         self.priors = bilby.core.prior.PriorDict()
         self.priors["m"] = bilby.core.prior.Uniform(0, 5, boundary="periodic")
         self.priors["c"] = bilby.core.prior.Uniform(-2, 2, boundary="reflective")
+        self.kwargs = dict(
+            save=False,
+            conversion_function=self.conversion_function,
+        )
         bilby.core.utils.check_directory_exists_and_if_not_mkdir("outdir")
 
+    @staticmethod
+    def conversion_function(parameters, likelihood, prior):
+        converted = parameters.copy()
+        if "derived" not in converted:
+            converted["derived"] = converted["m"] * converted["c"]
+        return converted
+
     def tearDown(self):
         del self.likelihood
         del self.priors
@@ -34,17 +45,21 @@ class TestRunningSamplers(unittest.TestCase):
         shutil.rmtree("outdir")
 
     def test_run_cpnest(self):
-        _ = bilby.run_sampler(
+        pytest.importorskip("cpnest")
+        res = bilby.run_sampler(
             likelihood=self.likelihood,
             priors=self.priors,
             sampler="cpnest",
             nlive=100,
-            save=False,
             resume=False,
+            **self.kwargs,
         )
+        assert "derived" in res.posterior
+        assert res.log_likelihood_evaluations is not None
 
     def test_run_dnest4(self):
-        _ = bilby.run_sampler(
+        pytest.importorskip("dnest4")
+        res = bilby.run_sampler(
             likelihood=self.likelihood,
             priors=self.priors,
             sampler="dnest4",
@@ -54,20 +69,26 @@ class TestRunningSamplers(unittest.TestCase):
             num_per_step=10,
             thread_steps=1,
             num_particles=50,
-            save=False,
+            **self.kwargs,
         )
+        assert "derived" in res.posterior
+        assert res.log_likelihood_evaluations is not None
 
     def test_run_dynesty(self):
-        _ = bilby.run_sampler(
+        pytest.importorskip("dynesty")
+        res = bilby.run_sampler(
             likelihood=self.likelihood,
             priors=self.priors,
             sampler="dynesty",
             nlive=100,
-            save=False,
+            **self.kwargs,
         )
+        assert "derived" in res.posterior
+        assert res.log_likelihood_evaluations is not None
 
     def test_run_dynamic_dynesty(self):
-        _ = bilby.run_sampler(
+        pytest.importorskip("dynesty")
+        res = bilby.run_sampler(
             likelihood=self.likelihood,
             priors=self.priors,
             sampler="dynamic_dynesty",
@@ -77,62 +98,79 @@ class TestRunningSamplers(unittest.TestCase):
             maxbatch=0,
             maxcall=100,
             bound="single",
-            save=False,
+            **self.kwargs,
         )
+        assert "derived" in res.posterior
+        assert res.log_likelihood_evaluations is not None
 
     def test_run_emcee(self):
-        _ = bilby.run_sampler(
+        pytest.importorskip("emcee")
+        res = bilby.run_sampler(
             likelihood=self.likelihood,
             priors=self.priors,
             sampler="emcee",
             iterations=1000,
             nwalkers=10,
-            save=False,
+            **self.kwargs,
         )
+        assert "derived" in res.posterior
+        assert res.log_likelihood_evaluations is not None
 
     def test_run_kombine(self):
-        _ = bilby.run_sampler(
+        pytest.importorskip("kombine")
+        res = bilby.run_sampler(
             likelihood=self.likelihood,
             priors=self.priors,
             sampler="kombine",
             iterations=2000,
             nwalkers=20,
-            save=False,
             autoburnin=False,
+            **self.kwargs,
         )
+        assert "derived" in res.posterior
+        assert res.log_likelihood_evaluations is not None
 
     def test_run_nestle(self):
-        _ = bilby.run_sampler(
+        pytest.importorskip("nestle")
+        res = bilby.run_sampler(
             likelihood=self.likelihood,
             priors=self.priors,
             sampler="nestle",
             nlive=100,
-            save=False,
+            **self.kwargs,
         )
+        assert "derived" in res.posterior
+        assert res.log_likelihood_evaluations is not None
 
     def test_run_nessai(self):
-        _ = bilby.run_sampler(
+        pytest.importorskip("nessai")
+        res = bilby.run_sampler(
             likelihood=self.likelihood,
             priors=self.priors,
             sampler="nessai",
             nlive=100,
             poolsize=1000,
             max_iteration=1000,
-            save=False,
+            **self.kwargs,
         )
+        assert "derived" in res.posterior
+        assert res.log_likelihood_evaluations is not None
 
     def test_run_pypolychord(self):
         pytest.importorskip("pypolychord")
-        _ = bilby.run_sampler(
+        res = bilby.run_sampler(
             likelihood=self.likelihood,
             priors=self.priors,
             sampler="pypolychord",
             nlive=100,
-            save=False,
+            **self.kwargs,
         )
+        assert "derived" in res.posterior
+        assert res.log_likelihood_evaluations is not None
 
     def test_run_ptemcee(self):
-        _ = bilby.run_sampler(
+        pytest.importorskip("ptemcee")
+        res = bilby.run_sampler(
             likelihood=self.likelihood,
             priors=self.priors,
             sampler="ptemcee",
@@ -141,60 +179,90 @@ class TestRunningSamplers(unittest.TestCase):
             burn_in_act=1,
             ntemps=1,
             frac_threshold=0.5,
-            save=False,
+            **self.kwargs,
         )
+        assert "derived" in res.posterior
+        assert res.log_likelihood_evaluations is not None
 
     @pytest.mark.skipif(sys.version_info[1] <= 6, reason="pymc3 is broken in py36")
+    @pytest.mark.xfail(
+        raises=AttributeError,
+        reason="Dependency issue with pymc3 causes attribute error on import",
+    )
     def test_run_pymc3(self):
-        _ = bilby.run_sampler(
+        pytest.importorskip("pymc3")
+        res = bilby.run_sampler(
             likelihood=self.likelihood,
             priors=self.priors,
             sampler="pymc3",
             draws=50,
             tune=50,
             n_init=250,
-            save=False,
+            **self.kwargs,
         )
+        assert "derived" in res.posterior
+        assert res.log_likelihood_evaluations is not None
 
     def test_run_pymultinest(self):
-        _ = bilby.run_sampler(
+        pytest.importorskip("pymultinest")
+        res = bilby.run_sampler(
             likelihood=self.likelihood,
             priors=self.priors,
             sampler="pymultinest",
             nlive=100,
-            save=False,
+            **self.kwargs,
         )
+        assert "derived" in res.posterior
+        assert res.log_likelihood_evaluations is not None
 
     def test_run_PTMCMCSampler(self):
-        _ = bilby.run_sampler(
+        pytest.importorskip("PTMCMCSampler")
+        res = bilby.run_sampler(
             likelihood=self.likelihood,
             priors=self.priors,
             sampler="PTMCMCsampler",
             Niter=101,
             burn=2,
             isave=100,
-            save=False,
+            **self.kwargs,
         )
+        assert "derived" in res.posterior
+        assert res.log_likelihood_evaluations is not None
 
     def test_run_ultranest(self):
+        pytest.importorskip("ultranest")
         # run using NestedSampler (with nlive specified)
-        _ = bilby.run_sampler(
-            likelihood=self.likelihood, priors=self.priors,
-            sampler="ultranest", nlive=100, save=False,
+        res = bilby.run_sampler(
+            likelihood=self.likelihood,
+            priors=self.priors,
+            sampler="ultranest",
+            nlive=100,
+            **self.kwargs,
         )
+        assert "derived" in res.posterior
+        assert res.log_likelihood_evaluations is not None
 
         # run using ReactiveNestedSampler (with no nlive given)
-        _ = bilby.run_sampler(
-            likelihood=self.likelihood, priors=self.priors,
-            sampler='ultranest', save=False,
+        res = bilby.run_sampler(
+            likelihood=self.likelihood,
+            priors=self.priors,
+            sampler="ultranest",
+            **self.kwargs,
         )
+        assert "derived" in res.posterior
+        assert res.log_likelihood_evaluations is not None
 
     def test_run_bilby_mcmc(self):
-        _ = bilby.run_sampler(
-            likelihood=self.likelihood, priors=self.priors,
-            sampler="bilby_mcmc", nsamples=200, save=False,
+        res = bilby.run_sampler(
+            likelihood=self.likelihood,
+            priors=self.priors,
+            sampler="bilby_mcmc",
+            nsamples=200,
+            **self.kwargs,
             printdt=1,
         )
+        assert "derived" in res.posterior
+        assert res.log_likelihood_evaluations is not None
 
 
 if __name__ == "__main__":