Merge branch 'restructre_time_frequency_tests' into 'master'

Restructre time frequency tests and fixing some recently surfaced bugs when using time domain models

See merge request !279

CHANGELOG.md

@@ -19,6 +19,7 @@ Changes currently on master, but not under a tag.
 - Added method to result to get injection recovery credible levels
 - Added function to generate a pp-plot from many results to core/result.py
 - Fixed a bug which caused `Interferometer.detector_tensor` not to update when `latitude`, `longitude`, `xarm_azimuth`, `yarm_azimuth`, `xarm_tilt`, `yarm_tilt` were updated.
+- Extracted time and frequency series behaviour from `WaveformGenerator` and `InterferometerStrainData` and moved it to `series.gw.CoupledTimeAndFrequencySeries`
 
 ### Changes
 - Switch the ordering the key-word arguments in `result.read_in_result` to put

bilby/gw/likelihood.py

@@ -284,7 +284,7 @@ class GravitationalWaveTransient(likelihood.Likelihood):
             self.interferometers.start_time + np.linspace(
                 0, self.interferometers.duration,
                 int(self.interferometers.duration / 2 *
-                    self.waveform_generator.sampling_frequency))[1:]
+                    self.waveform_generator.sampling_frequency + 1))[1:]
         self.time_prior_array =\
             self.priors['geocent_time'].prob(times) * delta_tc
 

bilby/gw/series.py

@@ -20,6 +20,12 @@ class CoupledTimeAndFrequencySeries(object):
         self.start_time = start_time
         self._frequency_array_updated = False
         self._time_array_updated = False
+        self._frequency_array = None
+        self._time_array = None
+
+    def __repr__(self):
+        return self.__class__.__name__ + '(duration={}, sampling_frequency={}, start_time={})'\
+            .format(self.duration, self.sampling_frequency, self.start_time)
 
     @property
     def frequency_array(self):
@@ -31,7 +37,7 @@ class CoupledTimeAndFrequencySeries(object):
         """
         if self._frequency_array_updated is False:
             if self.sampling_frequency and self.duration:
-                self.frequency_array = utils.create_frequency_series(
+                self._frequency_array = utils.create_frequency_series(
                     sampling_frequency=self.sampling_frequency,
                     duration=self.duration)
             else:

bilby/gw/waveform_generator.py

@@ -168,7 +168,7 @@ class WaveformGenerator(object):
         model_strain = dict()
         for key in transformed_model_strain:
             if transformation_function == utils.nfft:
-                model_strain[key], self.frequency_array = \
+                model_strain[key], _ = \
                     transformation_function(transformed_model_strain[key], self.sampling_frequency)
             else:
                 model_strain[key] = transformation_function(transformed_model_strain[key], self.sampling_frequency)

test/detector_test.py

@@ -518,42 +518,6 @@ class TestInterferometerStrainData(unittest.TestCase):
                 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_frequency_array_setting_direct(self):
-        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_array, np.array(np.array([5, 15, 25]))))
-
-    def test_duration_setting(self):
-        with mock.patch('bilby.core.utils.create_frequency_series') as m:
-            m.return_value = np.array([0, 1, 2])
-            self.ifosd.set_from_frequency_domain_strain(
-                frequency_domain_strain=np.array([0, 1, 2]), frequency_array=np.array([0, 1, 2]))
-            self.assertAlmostEqual(self.ifosd.duration, 1)
-
-    def test_sampling_frequency_setting(self):
-        with mock.patch('bilby.core.utils.create_frequency_series') as n:
-            with mock.patch('bilby.core.utils.get_sampling_frequency_and_duration_from_frequency_array') as m:
-                m.return_value = 8, 456
-                n.return_value = np.array([1, 2, 3])
-                self.ifosd.set_from_frequency_domain_strain(
-                    frequency_domain_strain=np.array([0, 1, 2]), frequency_array=np.array([0, 1, 2]))
-                self.assertEqual(8, self.ifosd.sampling_frequency)
-
-    def test_frequency_array_setting(self):
-        duration = 3
-        sampling_frequency = 1
-        with mock.patch('bilby.core.utils.create_frequency_series') as m:
-            m.return_value = [1, 2, 3]
-            self.ifosd.set_from_frequency_domain_strain(
-                frequency_domain_strain=np.array([0, 1, 2]), duration=duration,
-                sampling_frequency=sampling_frequency)
-            self.assertTrue(np.array_equal(
-                self.ifosd.frequency_array,
-                bilby.core.utils.create_frequency_series(duration=duration,
-                                                         sampling_frequency=sampling_frequency)))
-
     def test_set_data_fails(self):
         with mock.patch('bilby.core.utils.create_frequency_series') as m:
             m.return_value = [1, 2, 3]
@@ -606,60 +570,6 @@ class TestInterferometerStrainData(unittest.TestCase):
         self.assertTrue(np.all(
             self.ifosd.frequency_domain_strain == frequency_domain_strain * self.ifosd.frequency_mask))
 
-    def test_time_array_when_set(self):
-        test_array = np.array([1, 2, 3])
-        self.ifosd.time_array = test_array
-        self.assertTrue(np.array_equal(test_array, self.ifosd.time_array))
-
-    def test_time_array_when_not_set(self):
-        with mock.patch('bilby.core.utils.create_time_series') as m:
-            self.ifosd.start_time = 3
-            self.ifosd.sampling_frequency = 1000
-            self.ifosd.duration = 5
-            m.return_value = 4
-            self.assertEqual(m.return_value, self.ifosd.time_array)
-            m.assert_called_with(sampling_frequency=1000,
-                                 duration=5,
-                                 starting_time=3)
-
-    def test_time_array_without_sampling_frequency(self):
-        self.ifosd.sampling_frequency = None
-        self.ifosd.duration = 4
-        with self.assertRaises(ValueError):
-            test = self.ifosd.time_array
-
-    def test_time_array_without_duration(self):
-        self.ifosd.sampling_frequency = 4096
-        self.ifosd.duration = None
-        with self.assertRaises(ValueError):
-            test = self.ifosd.time_array
-
-    def test_frequency_array_when_set(self):
-        test_array = np.array([1, 2, 3])
-        self.ifosd.frequency_array = test_array
-        self.assertTrue(np.array_equal(test_array, self.ifosd.frequency_array))
-
-    def test_frequency_array_when_not_set(self):
-        with mock.patch('bilby.core.utils.create_frequency_series') as m:
-            m.return_value = [1, 2, 3]
-            self.ifosd.sampling_frequency = 1000
-            self.ifosd.duration = 5
-            self.assertListEqual(m.return_value, self.ifosd.frequency_array)
-            m.assert_called_with(sampling_frequency=1000,
-                                 duration=5)
-
-    def test_frequency_array_without_sampling_frequency(self):
-        self.ifosd.sampling_frequency = None
-        self.ifosd.duration = 4
-        with self.assertRaises(ValueError):
-            test = self.ifosd.frequency_array
-
-    def test_frequency_array_without_duration(self):
-        self.ifosd.sampling_frequency = 4096
-        self.ifosd.duration = None
-        with self.assertRaises(ValueError):
-            test = self.ifosd.frequency_array
-
     def test_time_within_data_before(self):
         self.ifosd.start_time = 3
         self.ifosd.duration = 2

test/series_test.py

+from __future__ import absolute_import
+import unittest
+import bilby
+import numpy as np
+
+
+class TestCoupledTimeAndFrequencySeries(unittest.TestCase):
+
+    def setUp(self):
+        self.duration = 2
+        self.sampling_frequency = 4096
+        self.start_time = -1
+        self.series = bilby.gw.series.CoupledTimeAndFrequencySeries(duration=self.duration,
+                                                                    sampling_frequency=self.sampling_frequency,
+                                                                    start_time=self.start_time)
+
+    def tearDown(self):
+        del self.duration
+        del self.sampling_frequency
+        del self.start_time
+        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)
+        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)
+
+    def test_start_time_from_init(self):
+        self.assertEqual(self.start_time, self.series.start_time)
+
+    def test_frequency_array_type(self):
+        self.assertIsInstance(self.series.frequency_array, np.ndarray)
+
+    def test_time_array_type(self):
+        self.assertIsInstance(self.series.time_array, np.ndarray)
+
+    def test_frequency_array_from_init(self):
+        expected = bilby.core.utils.create_frequency_series(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 = bilby.core.utils.create_time_series(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 = bilby.core.utils.create_frequency_series(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.assertAlmostEqual(new_duration, self.series.duration)
+        self.assertAlmostEqual(self.start_time, self.series.start_time)
+
+    def test_time_array_setter(self):
+        new_sampling_frequency = 100
+        new_duration = 3
+        new_start_time = 4
+        new_time_array = bilby.core.utils.create_time_series(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)
+        self.assertAlmostEqual(new_duration, self.series.duration, places=1)
+        self.assertAlmostEqual(new_start_time, self.series.start_time, places=1)
+
+    def test_time_array_without_sampling_frequency(self):
+        self.series.sampling_frequency = None
+        self.series.duration = 4
+        with self.assertRaises(ValueError):
+            test = self.series.time_array
+
+    def test_time_array_without_duration(self):
+        self.series.sampling_frequency = 4096
+        self.series.duration = None
+        with self.assertRaises(ValueError):
+            test = self.series.time_array
+
+    def test_frequency_array_without_sampling_frequency(self):
+        self.series.sampling_frequency = None
+        self.series.duration = 4
+        with self.assertRaises(ValueError):
+            test = self.series.frequency_array
+
+    def test_frequency_array_without_duration(self):
+        self.series.sampling_frequency = 4096
+        self.series.duration = None
+        with self.assertRaises(ValueError):
+            test = self.series.frequency_array