.gitlab-ci.yml

@@ -71,13 +71,13 @@ python-3.7:
       - docs/_build/html/
 
 # test example on python 3.6
-python-3.6:
-  stage: test
-  image: bilbydev/v2-dockerfile-test-suite-python36
-  script:
-    - python -m pip install .
-
-    - pytest
+#python-3.6:
+#  stage: test
+#  image: bilbydev/v2-dockerfile-test-suite-python36
+#  script:
+#    - python -m pip install .
+#
+#    - pytest
 
 # Tests run at a fixed schedule rather than on push
 scheduled-python-3.7:

CHANGELOG.md

 # All notable changes will be documented in this file
 
+## [0.6.3] 2020-01-03
+### Changed
+- Fixed an issue with the ROQ segment scaling (!690)
+
+## [0.6.2] 2019-12-20
+### Added
+- Introduced conditional prior sets (!332)(!673)(!674)
+- Introduced joint priors (!668)
+- Added a check to make sure sampling time exists before trying to update (!672)
+### Changed
+- Fixed a caching issue with the waveform generators (!630)
+- Fixed an issue that made the dynamic dynesty sampler not work (!667)
+- Changed the backend docker files (!669)
+- Fixed an error when plotting time domain data when using `filtfilt=True`
+- `Interped` priors now dynamically update when new `yy` values are set (!675)
+- Fixed the ROQ scaling checks (!678)
+
 ## [0.6.1] 2019-12-02
 
 HotFix release following 0.6.0 fixing a minor bug in the generation of derived

bilby/core/prior.py

@@ -2473,7 +2473,7 @@ class Interped(Prior):
 
         """
         self.xx = xx
-        self.yy = yy
+        self._yy = yy
         self.YY = None
         self.probability_density = None
         self.cumulative_distribution = None
@@ -2558,19 +2558,38 @@ class Interped(Prior):
         if '_minimum' in self.__dict__ and self._minimum < np.inf:
             self._update_instance()
 
+    @property
+    def yy(self):
+        """Return p(xx) values of the interpolated prior function.
+
+        Updates the prior distribution if it is changed
+
+        Returns
+        -------
+        array_like: p(xx) values
+
+        """
+        return self._yy
+
+    @yy.setter
+    def yy(self, yy):
+        self._yy = yy
+        self.__all_interpolated = interp1d(x=self.xx, y=self._yy, bounds_error=False, fill_value=0)
+        self._update_instance()
+
     def _update_instance(self):
         self.xx = np.linspace(self.minimum, self.maximum, len(self.xx))
-        self.yy = self.__all_interpolated(self.xx)
+        self._yy = self.__all_interpolated(self.xx)
         self._initialize_attributes()
 
     def _initialize_attributes(self):
-        if np.trapz(self.yy, self.xx) != 1:
+        if np.trapz(self._yy, self.xx) != 1:
             logger.debug('Supplied PDF for {} is not normalised, normalising.'.format(self.name))
-        self.yy /= np.trapz(self.yy, self.xx)
-        self.YY = cumtrapz(self.yy, self.xx, initial=0)
+        self._yy /= np.trapz(self._yy, self.xx)
+        self.YY = cumtrapz(self._yy, self.xx, initial=0)
         # Need last element of cumulative distribution to be exactly one.
         self.YY[-1] = 1
-        self.probability_density = interp1d(x=self.xx, y=self.yy, bounds_error=False, fill_value=0)
+        self.probability_density = interp1d(x=self.xx, y=self._yy, bounds_error=False, fill_value=0)
         self.cumulative_distribution = interp1d(x=self.xx, y=self.YY, bounds_error=False, fill_value=(0, 1))
         self.inverse_cumulative_distribution = interp1d(x=self.YY, y=self.xx, bounds_error=True)
 

bilby/core/utils.py

@@ -20,10 +20,10 @@ import pandas as pd
 
 logger = logging.getLogger('bilby')
 
-# Constants: values taken from LAL cd65f38ce43cef3a1dec217c060de25caf99bf14
+# Constants: values taken from LAL 505df9dd2e69b4812f1e8eee3a6d468ba7f80674
 speed_of_light = 299792458.0  # m/s
 parsec = 3.085677581491367e+16  # m
-solar_mass = 1.9885469549614615e+30  # Kg
+solar_mass = 1.9884099021470415e+30  # Kg
 radius_of_earth = 6378136.6  # m
 
 _TOL = 14

bilby/gw/detector/strain_data.py

@@ -216,6 +216,7 @@ class InterferometerStrainData(object):
         if not len(self.frequency_array) == len(frequency_domain_strain):
             raise ValueError("The frequency_array and the set strain have different lengths")
         self._frequency_domain_strain = frequency_domain_strain
+        self._time_domain_strain = None
 
     def to_gwpy_timeseries(self):
         """

bilby/gw/likelihood.py

@@ -835,8 +835,7 @@ class ROQGravitationalWaveTransient(GravitationalWaveTransient):
         If true, run tests using the roq_params to check the prior and data are
         valid for the ROQ
     roq_scale_factor: float
-        The ROQ scale factor used. WARNING: this does not apply the scaling,
-        but is only used for checking that the ROQ basis is appropriate.
+        The ROQ scale factor used.
     priors: dict, bilby.prior.PriorDict
         A dictionary of priors containing at least the geocent_time prior
     distance_marginalization_lookup_table: (dict, str), optional
@@ -1005,22 +1004,22 @@ class ROQGravitationalWaveTransient(GravitationalWaveTransient):
             logger.info(msg)
 
         roq_params = self.roq_params
-        roq_params['flow'] *= self.roq_scale_factor
-        roq_params['fhigh'] *= self.roq_scale_factor
-        roq_params['seglen'] /= self.roq_scale_factor
-        roq_params['chirpmassmin'] /= self.roq_scale_factor
-        roq_params['chirpmassmax'] /= self.roq_scale_factor
-        roq_params['compmin'] /= self.roq_scale_factor
-
-        if ifo.maximum_frequency > roq_params['fhigh']:
+        roq_minimum_frequency = roq_params['flow'] * self.roq_scale_factor
+        roq_maximum_frequency = roq_params['fhigh'] * self.roq_scale_factor
+        roq_segment_length = roq_params['seglen'] / self.roq_scale_factor
+        roq_minimum_chirp_mass = roq_params['chirpmassmin'] / self.roq_scale_factor
+        roq_maximum_chirp_mass = roq_params['chirpmassmax'] / self.roq_scale_factor
+        roq_minimum_component_mass = roq_params['compmin'] / self.roq_scale_factor
+
+        if ifo.maximum_frequency > roq_maximum_frequency:
             raise BilbyROQParamsRangeError(
                 "Requested maximum frequency {} larger than ROQ basis fhigh {}"
-                .format(ifo.maximum_frequency, roq_params['fhigh']))
-        if ifo.minimum_frequency < roq_params['flow']:
+                .format(ifo.maximum_frequency, roq_maximum_frequency))
+        if ifo.minimum_frequency < roq_minimum_frequency:
             raise BilbyROQParamsRangeError(
                 "Requested minimum frequency {} lower than ROQ basis flow {}"
-                .format(ifo.minimum_frequency, roq_params['flow']))
-        if ifo.strain_data.duration != roq_params['seglen']:
+                .format(ifo.minimum_frequency, roq_minimum_frequency))
+        if ifo.strain_data.duration != roq_segment_length:
             raise BilbyROQParamsRangeError(
                 "Requested duration differs from ROQ basis seglen")
 
@@ -1031,27 +1030,27 @@ class ROQGravitationalWaveTransient(GravitationalWaveTransient):
 
         if priors.minimum_chirp_mass is None:
             logger.warning("Unable to check minimum chirp mass ROQ bounds")
-        elif priors.minimum_chirp_mass < roq_params["chirpmassmin"]:
+        elif priors.minimum_chirp_mass < roq_minimum_chirp_mass:
             raise BilbyROQParamsRangeError(
                 "Prior minimum chirp mass {} less than ROQ basis bound {}"
                 .format(priors.minimum_chirp_mass,
-                        roq_params["chirpmassmin"]))
+                        roq_minimum_chirp_mass))
 
         if priors.maximum_chirp_mass is None:
             logger.warning("Unable to check maximum_chirp mass ROQ bounds")
-        elif priors.maximum_chirp_mass > roq_params["chirpmassmax"]:
+        elif priors.maximum_chirp_mass > roq_maximum_chirp_mass:
             raise BilbyROQParamsRangeError(
                 "Prior maximum chirp mass {} greater than ROQ basis bound {}"
                 .format(priors.maximum_chirp_mass,
-                        roq_params["chirpmassmax"]))
+                        roq_maximum_chirp_mass))
 
         if priors.minimum_component_mass is None:
             logger.warning("Unable to check minimum component mass ROQ bounds")
-        elif priors.minimum_component_mass < roq_params["compmin"]:
+        elif priors.minimum_component_mass < roq_minimum_component_mass:
             raise BilbyROQParamsRangeError(
                 "Prior minimum component mass {} less than ROQ basis bound {}"
                 .format(priors.minimum_component_mass,
-                        roq_params["compmin"]))
+                        roq_minimum_component_mass))
 
     def _set_weights(self, linear_matrix, quadratic_matrix):
         """ Setup the time-dependent ROQ weights.
@@ -1077,11 +1076,15 @@ class ROQGravitationalWaveTransient(GravitationalWaveTransient):
         for ifo in self.interferometers:
             if self.roq_params is not None:
                 self.perform_roq_params_check(ifo)
+                # Get scaled ROQ quantities
+                roq_scaled_minimum_frequency = self.roq_params['flow'] * self.roq_scale_factor
+                roq_scaled_maximum_frequency = self.roq_params['fhigh'] * self.roq_scale_factor
+                roq_scaled_segment_length = self.roq_params['seglen'] / self.roq_scale_factor
                 # Generate frequencies for the ROQ
                 roq_frequencies = create_frequency_series(
-                    sampling_frequency=self.roq_params['fhigh'] * 2,
-                    duration=self.roq_params['seglen'])
-                roq_mask = roq_frequencies >= self.roq_params['flow']
+                    sampling_frequency=roq_scaled_maximum_frequency * 2,
+                    duration=roq_scaled_segment_length)
+                roq_mask = roq_frequencies >= roq_scaled_minimum_frequency
                 roq_frequencies = roq_frequencies[roq_mask]
                 overlap_frequencies, ifo_idxs, roq_idxs = np.intersect1d(
                     ifo.frequency_array[ifo.frequency_mask], roq_frequencies,

bilby/gw/prior.py

@@ -4,7 +4,7 @@ import copy
 import numpy as np
 from scipy.interpolate import InterpolatedUnivariateSpline
 
-from ..core.prior import (ConditionalPriorDict, PriorDict, Uniform, Prior, DeltaFunction, Gaussian,
+from ..core.prior import (PriorDict, Uniform, Prior, DeltaFunction, Gaussian,
                           Interped, Constraint, conditional_prior_factory)
 from ..core.utils import infer_args_from_method, logger
 from .conversion import (
@@ -307,7 +307,7 @@ class AlignedSpin(Interped):
                                           boundary=boundary)
 
 
-class CBCPriorDict(ConditionalPriorDict):
+class CBCPriorDict(PriorDict):
     @property
     def minimum_chirp_mass(self):
         mass_1 = None

examples/gw_examples/injection_examples/roq_example.py

@@ -32,12 +32,11 @@ freq_nodes_quadratic = np.load("fnodes_quadratic.npy") * scale_factor
 
 # Load the parameters describing the valid parameters for the basis.
 params = np.genfromtxt("params.dat", names=True)
-params['flow'] *= scale_factor
-params['fhigh'] *= scale_factor
-params['seglen'] /= scale_factor
-params['chirpmassmin'] /= scale_factor
-params['chirpmassmax'] /= scale_factor
-params['compmin'] /= scale_factor
+
+# Get scaled ROQ quantities
+minimum_chirp_mass = params['chirpmassmin'] / scale_factor
+maximum_chirp_mass = params['chirpmassmax'] / scale_factor
+minimum_component_mass = params['compmin'] / scale_factor
 
 np.random.seed(170808)
 
@@ -84,10 +83,10 @@ for key in ['a_1', 'a_2', 'tilt_1', 'tilt_2', 'theta_jn', 'phase', 'psi', 'ra',
             'dec', 'phi_12', 'phi_jl', 'luminosity_distance']:
     priors[key] = injection_parameters[key]
 for key in ['mass_1', 'mass_2']:
-    priors[key].minimum = max(priors[key].minimum, params['compmin'])
+    priors[key].minimum = max(priors[key].minimum, minimum_component_mass)
 priors['chirp_mass'] = bilby.core.prior.Constraint(
-    name='chirp_mass', minimum=float(params['chirpmassmin']),
-    maximum=float(params['chirpmassmax']))
+    name='chirp_mass', minimum=float(minimum_chirp_mass),
+    maximum=float(maximum_chirp_mass))
 priors['mass_ratio'] = bilby.core.prior.Constraint(0.125, 1, name='mass_ratio')
 priors['geocent_time'] = bilby.core.prior.Uniform(
     injection_parameters['geocent_time'] - 0.1,
@@ -96,7 +95,7 @@ priors['geocent_time'] = bilby.core.prior.Uniform(
 likelihood = bilby.gw.likelihood.ROQGravitationalWaveTransient(
     interferometers=ifos, waveform_generator=search_waveform_generator,
     linear_matrix=basis_matrix_linear, quadratic_matrix=basis_matrix_quadratic,
-    priors=priors, roq_params=params)
+    priors=priors, roq_params=params, roq_scale_factor=scale_factor)
 
 # write the weights to file so they can be loaded multiple times
 likelihood.save_weights('weights.npz')

setup.py

@@ -57,7 +57,7 @@ def readfile(filename):
     return filecontents
 
 
-VERSION = '0.6.1'
+VERSION = '0.6.3'
 version_file = write_version_file(VERSION)
 long_description = get_long_description()
 

test/detector_test.py

@@ -366,6 +366,13 @@ class TestInterferometer(unittest.TestCase):
         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))
+
     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,

test/gw_likelihood_test.py

@@ -45,7 +45,7 @@ class TestBasicGWTransient(unittest.TestCase):
         """Test log likelihood matches precomputed value"""
         self.likelihood.log_likelihood()
         self.assertAlmostEqual(self.likelihood.log_likelihood(),
-                               -4055.25243177871, 3)
+                               -4055.265194950631, 3)
 
     def test_log_likelihood_ratio(self):
         """Test log likelihood ratio returns the correct value"""
@@ -114,7 +114,7 @@ class TestGWTransient(unittest.TestCase):
         """Test log likelihood matches precomputed value"""
         self.likelihood.log_likelihood()
         self.assertAlmostEqual(self.likelihood.log_likelihood(),
-                               -4055.25243177871, 3)
+                               -4055.265194950631, 3)
 
     def test_log_likelihood_ratio(self):
         """Test log likelihood ratio returns the correct value"""
@@ -772,12 +772,6 @@ class TestRescaledROQLikelihood(unittest.TestCase):
 
         scale_factor = 0.5
         params = np.genfromtxt(self.params_file, names=True)
-        params['flow'] *= scale_factor
-        params['fhigh'] *= scale_factor
-        params['seglen'] /= scale_factor
-        params['chirpmassmin'] /= scale_factor
-        params['chirpmassmax'] /= scale_factor
-        params['compmin'] /= scale_factor
 
         self.duration = 4 / scale_factor
         self.sampling_frequency = 2048 * scale_factor
@@ -807,8 +801,9 @@ class TestRescaledROQLikelihood(unittest.TestCase):
 
         self.roq = bilby.gw.likelihood.ROQGravitationalWaveTransient(
             interferometers=ifos, waveform_generator=self.roq_wfg,
-            linear_matrix=linear_matrix_file, roq_params=params,
-            quadratic_matrix=quadratic_matrix_file, priors=self.priors)
+            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):