bilby/gw/__init__.py

-from . import (calibration, conversion, detector, likelihood, prior, source,
+from . import (calibration, conversion, detector, likelihood, prior, series, source,
                utils, waveform_generator)
 
 from .waveform_generator import WaveformGenerator

bilby/gw/conversion.py

@@ -4,6 +4,8 @@ from pandas import DataFrame
 
 from ..core.utils import logger, solar_mass
 from ..core.prior import DeltaFunction, Interped
+from .utils import lalsim_SimInspiralTransformPrecessingNewInitialConditions
+
 
 try:
     from astropy.cosmology import z_at_value, Planck15
@@ -12,12 +14,6 @@ except ImportError:
     logger.warning("You do not have astropy installed currently. You will"
                    " not be able to use some of the prebuilt functions.")
 
-try:
-    import lalsimulation as lalsim
-except ImportError:
-    logger.warning("You do not have lalsuite installed currently. You will"
-                   " not be able to use some of the prebuilt functions.")
-
 
 def redshift_to_luminosity_distance(redshift):
     return Planck15.luminosity_distance(redshift).value
@@ -87,10 +83,12 @@ def transform_precessing_spins(theta_jn, phi_jl, tilt_1, tilt_2, phi_12, a_1,
     spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z: float
         Cartesian spin components
     """
-    iota, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z = \
-        lalsim.SimInspiralTransformPrecessingNewInitialConditions(
-            theta_jn, phi_jl, tilt_1, tilt_2, phi_12, a_1, a_2, mass_1,
-            mass_2, reference_frequency, phase)
+
+    iota, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z = (
+        lalsim_SimInspiralTransformPrecessingNewInitialConditions(
+            theta_jn, phi_jl, tilt_1, tilt_2, phi_12, a_1, a_2, mass_1, mass_2,
+            reference_frequency, phase))
+
     return iota, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z
 
 

bilby/gw/detector.py

@@ -11,6 +11,7 @@ from . import utils as gwutils
 from ..core import utils
 from ..core.utils import logger
 from .calibration import Recalibrate
+from .series import CoupledTimeAndFrequencySeries
 
 try:
     import gwpy
@@ -233,57 +234,14 @@ class InterferometerStrainData(object):
         self.roll_off = roll_off
         self.window_factor = 1
 
-        self._set_time_and_frequency_array_parameters(None, None, None)
+        self._times_and_frequencies = CoupledTimeAndFrequencySeries()
+        # self._set_time_and_frequency_array_parameters(None, None, None)
 
         self._frequency_domain_strain = None
         self._frequency_array = None
         self._time_domain_strain = None
         self._time_array = None
 
-    @property
-    def frequency_array(self):
-        """ Frequencies of the data in Hz """
-        if self._frequency_array is not None:
-            return self._frequency_array
-        else:
-            self._calculate_frequency_array()
-            return self._frequency_array
-
-    @frequency_array.setter
-    def frequency_array(self, frequency_array):
-        self._frequency_array = frequency_array
-
-    @property
-    def time_array(self):
-        """ Time of the data in seconds """
-        if self._time_array is not None:
-            return self._time_array
-        else:
-            self._calculate_time_array()
-            return self._time_array
-
-    @time_array.setter
-    def time_array(self, time_array):
-        self._time_array = time_array
-
-    def _calculate_time_array(self):
-        """ Calculate the time array """
-        if (self.sampling_frequency is None) or (self.duration is None):
-            raise ValueError(
-                "You have not specified the sampling_frequency and duration")
-
-        self.time_array = utils.create_time_series(
-            sampling_frequency=self.sampling_frequency, duration=self.duration,
-            starting_time=self.start_time)
-
-    def _calculate_frequency_array(self):
-        """ Calculate the frequency array """
-        if (self.sampling_frequency is None) or (self.duration is None):
-            raise ValueError(
-                "You have not specified the sampling_frequency and duration")
-        self.frequency_array = utils.create_frequency_series(
-            sampling_frequency=self.sampling_frequency, duration=self.duration)
-
     def time_within_data(self, time):
         """ Check if time is within the data span
 
@@ -503,10 +461,9 @@ class InterferometerStrainData(object):
         elif array is not None:
             if domain == 'time':
                 self.time_array = array
-                sampling_frequency, duration = utils.get_sampling_frequency_and_duration_from_time_array(array)
             elif domain == 'frequency':
                 self.frequency_array = array
-                sampling_frequency, duration = utils.get_sampling_frequency_and_duration_from_frequency_array(array)
+            return
         elif sampling_frequency is None or duration is None:
             raise ValueError(
                 "You must provide both sampling_frequency and duration")
@@ -744,9 +701,51 @@ class InterferometerStrainData(object):
         self.set_from_gwpy_timeseries(strain)
 
     def _set_time_and_frequency_array_parameters(self, duration, sampling_frequency, start_time):
-        self.sampling_frequency = sampling_frequency
-        self.duration = duration
-        self.start_time = start_time
+        self._times_and_frequencies = CoupledTimeAndFrequencySeries(duration=duration,
+                                                                    sampling_frequency=sampling_frequency,
+                                                                    start_time=start_time)
+
+    @property
+    def sampling_frequency(self):
+        return self._times_and_frequencies.sampling_frequency
+
+    @sampling_frequency.setter
+    def sampling_frequency(self, sampling_frequency):
+        self._times_and_frequencies.sampling_frequency = sampling_frequency
+
+    @property
+    def duration(self):
+        return self._times_and_frequencies.duration
+
+    @duration.setter
+    def duration(self, duration):
+        self._times_and_frequencies.duration = duration
+
+    @property
+    def start_time(self):
+        return self._times_and_frequencies.start_time
+
+    @start_time.setter
+    def start_time(self, start_time):
+        self._times_and_frequencies.start_time = start_time
+
+    @property
+    def frequency_array(self):
+        """ Frequencies of the data in Hz """
+        return self._times_and_frequencies.frequency_array
+
+    @frequency_array.setter
+    def frequency_array(self, frequency_array):
+        self._times_and_frequencies.frequency_array = frequency_array
+
+    @property
+    def time_array(self):
+        """ Time of the data in seconds """
+        return self._times_and_frequencies.time_array
+
+    @time_array.setter
+    def time_array(self, time_array):
+        self._times_and_frequencies.time_array = time_array
 
 
 class Interferometer(object):

bilby/gw/series.py

+from ..core import utils
+
+
+class CoupledTimeAndFrequencySeries(object):
+
+    def __init__(self, duration=None, sampling_frequency=None, start_time=0):
+        """ A waveform generator
+
+    Parameters
+    ----------
+    sampling_frequency: float, optional
+        The sampling frequency
+    duration: float, optional
+        Time duration of data
+    start_time: float, optional
+        Starting time of the time array
+        """
+        self.duration = duration
+        self.sampling_frequency = sampling_frequency
+        self.start_time = start_time
+        self._frequency_array_updated = False
+        self._time_array_updated = False
+
+    @property
+    def frequency_array(self):
+        """ Frequency array for the waveforms. Automatically updates if sampling_frequency or duration are updated.
+
+        Returns
+        -------
+        array_like: The frequency array
+        """
+        if self._frequency_array_updated is False:
+            if self.sampling_frequency and self.duration:
+                self.frequency_array = utils.create_frequency_series(
+                    sampling_frequency=self.sampling_frequency,
+                    duration=self.duration)
+            else:
+                raise ValueError('Can not calculate a frequency series without a '
+                                 'legitimate sampling_frequency ({}) or duration ({})'
+                                 .format(self.sampling_frequency, self.duration))
+
+        return self._frequency_array
+
+    @frequency_array.setter
+    def frequency_array(self, frequency_array):
+        self._frequency_array = frequency_array
+        self._sampling_frequency, self._duration = \
+            utils.get_sampling_frequency_and_duration_from_frequency_array(frequency_array)
+        self._frequency_array_updated = True
+
+    @property
+    def time_array(self):
+        """ Time array for the waveforms. Automatically updates if sampling_frequency or duration are updated.
+
+        Returns
+        -------
+        array_like: The time array
+        """
+
+        if self._time_array_updated is False:
+            if self.sampling_frequency and self.duration:
+                self._time_array = utils.create_time_series(
+                    sampling_frequency=self.sampling_frequency,
+                    duration=self.duration,
+                    starting_time=self.start_time)
+            else:
+                raise ValueError('Can not calculate a time series without a '
+                                 'legitimate sampling_frequency ({}) or duration ({})'
+                                 .format(self.sampling_frequency, self.duration))
+
+            self._time_array_updated = True
+        return self._time_array
+
+    @time_array.setter
+    def time_array(self, time_array):
+        self._time_array = time_array
+        self._sampling_frequency, self._duration = \
+            utils.get_sampling_frequency_and_duration_from_time_array(time_array)
+        self._start_time = time_array[0]
+        self._time_array_updated = True
+
+    @property
+    def duration(self):
+        """ Allows one to set the time duration and automatically updates the frequency and time array.
+
+        Returns
+        -------
+        float: The time duration.
+
+        """
+        return self._duration
+
+    @duration.setter
+    def duration(self, duration):
+        self._duration = duration
+        self._frequency_array_updated = False
+        self._time_array_updated = False
+
+    @property
+    def sampling_frequency(self):
+        """ Allows one to set the sampling frequency and automatically updates the frequency and time array.
+
+        Returns
+        -------
+        float: The sampling frequency.
+
+        """
+        return self._sampling_frequency
+
+    @sampling_frequency.setter
+    def sampling_frequency(self, sampling_frequency):
+        self._sampling_frequency = sampling_frequency
+        self._frequency_array_updated = False
+        self._time_array_updated = False
+
+    @property
+    def start_time(self):
+        return self._start_time
+
+    @start_time.setter
+    def start_time(self, start_time):
+        self._start_time = start_time
+        self._time_array_updated = False

bilby/gw/source.py

@@ -4,12 +4,16 @@ import numpy as np
 
 from ..core import utils
 from ..core.utils import logger
+from .utils import (lalsim_SimInspiralTransformPrecessingNewInitialConditions,
+                    lalsim_GetApproximantFromString,
+                    lalsim_SimInspiralChooseFDWaveform,
+                    lalsim_SimInspiralWaveformParamsInsertTidalLambda1,
+                    lalsim_SimInspiralWaveformParamsInsertTidalLambda2)
 
 try:
-    import lalsimulation as lalsim
     import lal
 except ImportError:
-    logger.warning("You do not have lalsuite installed currently. You will "
+    logger.warning("You do not have lalsuite installed currently. You will"
                    " not be able to use some of the prebuilt functions.")
 
 
@@ -74,9 +78,10 @@ def lal_binary_black_hole(
         spin_2y = 0
         spin_2z = a_2
     else:
-        iota, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z = \
-            lalsim.SimInspiralTransformPrecessingNewInitialConditions(
-                iota, phi_jl, tilt_1, tilt_2, phi_12, a_1, a_2, mass_1, mass_2, reference_frequency, phase)
+        iota, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z = (
+            lalsim_SimInspiralTransformPrecessingNewInitialConditions(
+                iota, phi_jl, tilt_1, tilt_2, phi_12, a_1, a_2, mass_1,
+                mass_2, reference_frequency, phase))
 
     longitude_ascending_nodes = 0.0
     eccentricity = 0.0
@@ -84,12 +89,12 @@ def lal_binary_black_hole(
 
     waveform_dictionary = None
 
-    approximant = lalsim.GetApproximantFromString(waveform_approximant)
+    approximant = lalsim_GetApproximantFromString(waveform_approximant)
 
     maximum_frequency = frequency_array[-1]
     delta_frequency = frequency_array[1] - frequency_array[0]
 
-    hplus, hcross = lalsim.SimInspiralChooseFDWaveform(
+    hplus, hcross = lalsim_SimInspiralChooseFDWaveform(
         mass_1, mass_2, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y,
         spin_2z, luminosity_distance, iota, phase,
         longitude_ascending_nodes, eccentricity, mean_per_ano, delta_frequency,
@@ -159,12 +164,12 @@ def lal_eccentric_binary_black_hole_no_spins(
 
     waveform_dictionary = None
 
-    approximant = lalsim.GetApproximantFromString(waveform_approximant)
+    approximant = lalsim_GetApproximantFromString(waveform_approximant)
 
     maximum_frequency = frequency_array[-1]
     delta_frequency = frequency_array[1] - frequency_array[0]
 
-    hplus, hcross = lalsim.SimInspiralChooseFDWaveform(
+    hplus, hcross = lalsim_SimInspiralChooseFDWaveform(
         mass_1, mass_2, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y,
         spin_2z, luminosity_distance, iota, phase,
         longitude_ascending_nodes, eccentricity, mean_per_ano, delta_frequency,
@@ -306,15 +311,15 @@ def lal_binary_neutron_star(
     mean_per_ano = 0.0
 
     waveform_dictionary = lal.CreateDict()
-    lalsim.SimInspiralWaveformParamsInsertTidalLambda1(waveform_dictionary, lambda_1)
-    lalsim.SimInspiralWaveformParamsInsertTidalLambda2(waveform_dictionary, lambda_2)
+    lalsim_SimInspiralWaveformParamsInsertTidalLambda1(waveform_dictionary, lambda_1)
+    lalsim_SimInspiralWaveformParamsInsertTidalLambda2(waveform_dictionary, lambda_2)
 
-    approximant = lalsim.GetApproximantFromString(waveform_approximant)
+    approximant = lalsim_GetApproximantFromString(waveform_approximant)
 
     maximum_frequency = frequency_array[-1]
     delta_frequency = frequency_array[1] - frequency_array[0]
 
-    hplus, hcross = lalsim.SimInspiralChooseFDWaveform(
+    hplus, hcross = lalsim_SimInspiralChooseFDWaveform(
         mass_1, mass_2, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y,
         spin_2z, luminosity_distance, iota, phase,
         longitude_ascending_nodes, eccentricity, mean_per_ano, delta_frequency,

bilby/gw/utils.py

@@ -14,6 +14,12 @@ except ImportError:
     logger.warning("You do not have gwpy installed currently. You will "
                    " not be able to use some of the prebuilt functions.")
 
+try:
+    import lalsimulation as lalsim
+except ImportError:
+    logger.warning("You do not have lalsuite installed currently. You will"
+                   " not be able to use some of the prebuilt functions.")
+
 
 def asd_from_freq_series(freq_data, df):
     """
@@ -588,3 +594,77 @@ def plot_skymap(result, center='120d -40d', nside=512):
     lat.set_ticks_visible(False)
 
     fig.savefig('{}/{}_skymap.png'.format(result.outdir, result.label))
+
+
+def lalsim_SimInspiralTransformPrecessingNewInitialConditions(
+        theta_jn, phi_jl, tilt_1, tilt_2, phi_12, a_1, a_2, mass_1, mass_2,
+        reference_frequency, phase):
+
+    for arg in (theta_jn, phi_jl, tilt_1, tilt_2, phi_12, a_1, a_2, mass_1,
+                mass_2, reference_frequency, phase):
+        try:
+            arg = float(arg)
+        except ValueError:
+            raise ValueError("Unable to convert inputs to floats")
+
+    return lalsim.SimInspiralTransformPrecessingNewInitialConditions(
+        theta_jn, phi_jl, tilt_1, tilt_2, phi_12, a_1, a_2, mass_1, mass_2,
+        reference_frequency, phase)
+
+
+def lalsim_GetApproximantFromString(waveform_approximant):
+    if isinstance(waveform_approximant, str):
+        return lalsim.GetApproximantFromString(waveform_approximant)
+    else:
+        raise ValueError("waveform_approximant must be of type str")
+
+
+def lalsim_SimInspiralChooseFDWaveform(
+        mass_1, mass_2, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y,
+        spin_2z, luminosity_distance, iota, phase,
+        longitude_ascending_nodes, eccentricity, mean_per_ano, delta_frequency,
+        minimum_frequency, maximum_frequency, reference_frequency,
+        waveform_dictionary, approximant):
+
+    for arg in (mass_1, mass_2, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y,
+                spin_2z, luminosity_distance, iota, phase,
+                longitude_ascending_nodes, eccentricity, mean_per_ano,
+                delta_frequency, minimum_frequency, maximum_frequency,
+                reference_frequency):
+            try:
+                arg = float(arg)
+            except ValueError:
+                raise ValueError("Unable to convert inputs to floats")
+
+    # Note, this is the approximant number returns by GetApproximantFromString
+    if isinstance(approximant, int) is False:
+        raise ValueError("approximant not an int")
+
+    return lalsim.SimInspiralChooseFDWaveform(
+        mass_1, mass_2, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y,
+        spin_2z, luminosity_distance, iota, phase,
+        longitude_ascending_nodes, eccentricity, mean_per_ano, delta_frequency,
+        minimum_frequency, maximum_frequency, reference_frequency,
+        waveform_dictionary, approximant)
+
+
+def lalsim_SimInspiralWaveformParamsInsertTidalLambda1(
+        waveform_dictionary, lambda_1):
+    try:
+        lambda_1 = float(lambda_1)
+    except ValueError:
+        raise ValueError("Unable to convert lambda_1 to float")
+
+    return lalsim.SimInspiralWaveformParamsInsertTidalLambda1(
+        waveform_dictionary, lambda_1)
+
+
+def lalsim_SimInspiralWaveformParamsInsertTidalLambda2(
+        waveform_dictionary, lambda_2):
+    try:
+        lambda_1 = float(lambda_2)
+    except ValueError:
+        raise ValueError("Unable to convert lambda_2 to float")
+
+    return lalsim.SimInspiralWaveformParamsInsertTidalLambda1(
+        waveform_dictionary, lambda_1)

bilby/gw/waveform_generator.py

 import numpy as np
 from ..core import utils
+from ..gw.series import CoupledTimeAndFrequencySeries
 
 
 class WaveformGenerator(object):
@@ -41,6 +42,9 @@ class WaveformGenerator(object):
         the WaveformGenerator object and initialised to `None`.
 
         """
+        self._times_and_frequencies = CoupledTimeAndFrequencySeries(duration=duration,
+                                                                    sampling_frequency=sampling_frequency,
+                                                                    start_time=start_time)
         self.duration = duration
         self.sampling_frequency = sampling_frequency
         self.start_time = start_time
@@ -57,8 +61,6 @@ class WaveformGenerator(object):
             self.waveform_arguments = dict()
         if isinstance(parameters, dict):
             self.parameters = parameters
-        self.__frequency_array_updated = False
-        self.__time_array_updated = False
 
     def __repr__(self):
         if self.frequency_domain_source_model is not None:
@@ -171,48 +173,6 @@ class WaveformGenerator(object):
                 model_strain[key] = transformation_function(transformed_model_strain[key], self.sampling_frequency)
         return model_strain
 
-    @property
-    def frequency_array(self):
-        """ Frequency array for the waveforms. Automatically updates if sampling_frequency or duration are updated.
-
-        Returns
-        -------
-        array_like: The frequency array
-        """
-        if self.__frequency_array_updated is False:
-            self.frequency_array = utils.create_frequency_series(
-                self.sampling_frequency,
-                self.duration)
-        return self.__frequency_array
-
-    @frequency_array.setter
-    def frequency_array(self, frequency_array):
-        self.__frequency_array = frequency_array
-        self.__frequency_array_updated = True
-
-    @property
-    def time_array(self):
-        """ Time array for the waveforms. Automatically updates if sampling_frequency or duration are updated.
-
-        Returns
-        -------
-        array_like: The time array
-        """
-
-        if self.__time_array_updated is False:
-            self.__time_array = utils.create_time_series(
-                self.sampling_frequency,
-                self.duration,
-                self.start_time)
-
-            self.__time_array_updated = True
-        return self.__time_array
-
-    @time_array.setter
-    def time_array(self, time_array):
-        self.__time_array = time_array
-        self.__time_array_updated = True
-
     @property
     def parameters(self):
         """ The dictionary of parameters for source model.
@@ -265,6 +225,34 @@ class WaveformGenerator(object):
                                  'model must be provided.')
         return set(utils.infer_parameters_from_function(model))
 
+    @property
+    def frequency_array(self):
+        """ Frequency array for the waveforms. Automatically updates if sampling_frequency or duration are updated.
+
+        Returns
+        -------
+        array_like: The frequency array
+        """
+        return self._times_and_frequencies.frequency_array
+
+    @frequency_array.setter
+    def frequency_array(self, frequency_array):
+        self._times_and_frequencies.frequency_array = frequency_array
+
+    @property
+    def time_array(self):
+        """ Time array for the waveforms. Automatically updates if sampling_frequency or duration are updated.
+
+        Returns
+        -------
+        array_like: The time array
+        """
+        return self._times_and_frequencies.time_array
+
+    @time_array.setter
+    def time_array(self, time_array):
+        self._times_and_frequencies.time_array = time_array
+
     @property
     def duration(self):
         """ Allows one to set the time duration and automatically updates the frequency and time array.
@@ -274,13 +262,11 @@ class WaveformGenerator(object):
         float: The time duration.
 
         """
-        return self.__duration
+        return self._times_and_frequencies.duration
 
     @duration.setter
     def duration(self, duration):
-        self.__duration = duration
-        self.__frequency_array_updated = False
-        self.__time_array_updated = False
+        self._times_and_frequencies.duration = duration
 
     @property
     def sampling_frequency(self):
@@ -291,19 +277,16 @@ class WaveformGenerator(object):
         float: The sampling frequency.
 
         """
-        return self.__sampling_frequency
+        return self._times_and_frequencies.sampling_frequency
 
     @sampling_frequency.setter
     def sampling_frequency(self, sampling_frequency):
-        self.__sampling_frequency = sampling_frequency
-        self.__frequency_array_updated = False
-        self.__time_array_updated = False
+        self._times_and_frequencies.sampling_frequency = sampling_frequency
 
     @property
     def start_time(self):
-        return self.__start_time
+        return self._times_and_frequencies.start_time
 
     @start_time.setter
-    def start_time(self, starting_time):
-        self.__start_time = starting_time
-        self.__time_array_updated = False
+    def start_time(self, start_time):
+        self._times_and_frequencies.start_time = start_time

test/detector_test.py

@@ -459,20 +459,20 @@ class TestInterferometerStrainData(unittest.TestCase):
             self.ifosd.frequency_domain_strain == frequency_domain_strain * self.ifosd.frequency_mask))
 
     def test_time_array_when_set(self):
-        test_array = np.array([1])
+        test_array = np.array([1, 2, 3])
         self.ifosd.time_array = test_array
-        self.assertTrue(test_array, self.ifosd.time_array)
-
-    @patch.object(bilby.core.utils, 'create_time_series')
-    def test_time_array_when_not_set(self, 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=self.ifosd.sampling_frequency,
-                             duration=self.ifosd.duration,
-                             starting_time=self.ifosd.start_time)
+        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
@@ -487,18 +487,18 @@ class TestInterferometerStrainData(unittest.TestCase):
             test = self.ifosd.time_array
 
     def test_frequency_array_when_set(self):
-        test_array = np.array([1])
+        test_array = np.array([1, 2, 3])
         self.ifosd.frequency_array = test_array
-        self.assertTrue(test_array, self.ifosd.frequency_array)
+        self.assertTrue(np.array_equal(test_array, self.ifosd.frequency_array))
 
-    @patch.object(bilby.core.utils, 'create_frequency_series')
-    def test_time_array_when_not_set(self, m):
-        self.ifosd.sampling_frequency = 1000
-        self.ifosd.duration = 5
-        m.return_value = 4
-        self.assertEqual(m.return_value, self.ifosd.frequency_array)
-        m.assert_called_with(sampling_frequency=self.ifosd.sampling_frequency,
-                             duration=self.ifosd.duration)
+    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
@@ -565,8 +565,8 @@ class TestInterferometerStrainData(unittest.TestCase):
         m.return_value = 5
         self.ifosd.sampling_frequency = 200
         self.ifosd.duration = 4
-        self.ifosd._frequency_domain_strain = self.ifosd.frequency_array
         self.ifosd.sampling_frequency = 123
+        self.ifosd.frequency_domain_strain = self.ifosd.frequency_array
         self.assertEqual(m.return_value, self.ifosd.time_domain_strain)
 
     def test_time_domain_strain_not_set(self):
@@ -719,14 +719,32 @@ class TestInterferometerList(unittest.TestCase):
         self.assertEqual(self.ifo2, ifo_list[1])
 
     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.strain_data.set_from_frequency_domain_strain(
-            np.linspace(0, 4096, 4097), sampling_frequency=4096, duration=3)
+            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.strain_data.set_from_frequency_domain_strain(
-            np.linspace(0, 4096, 4097), sampling_frequency=234, duration=2)
+            self.frequency_arrays, sampling_frequency=2048, duration=2)
         with self.assertRaises(ValueError):
             bilby.gw.detector.InterferometerList([self.ifo1, self.ifo2])