Resolve "sampling_frequency and duration should be saved in the CBCResult"

bilby/gw/likelihood.py

@@ -91,14 +91,6 @@ class GravitationalWaveTransient(likelihood.Likelihood):
         self.phase_marginalization = phase_marginalization
         self.priors = priors
         self._check_set_duration_and_sampling_frequency_of_waveform_generator()
-        self.meta_data = dict(
-            interferometers=self.interferometers.meta_data,
-            time_marginalization=self.time_marginalization,
-            phase_marginalization=self.phase_marginalization,
-            distance_marginalization=self.distance_marginalization,
-            waveform_arguments=waveform_generator.waveform_arguments,
-            frequency_domain_source_model=str(
-                waveform_generator.frequency_domain_source_model))
 
         if self.time_marginalization:
             self._check_prior_is_set(key='geocent_time')
@@ -635,6 +627,20 @@ class GravitationalWaveTransient(likelihood.Likelihood):
         for mode in signal:
             signal[mode] *= self._ref_dist / new_distance
 
+    @property
+    def meta_data(self):
+        return dict(
+            interferometers=self.interferometers.meta_data,
+            time_marginalization=self.time_marginalization,
+            phase_marginalization=self.phase_marginalization,
+            distance_marginalization=self.distance_marginalization,
+            waveform_arguments=self.waveform_generator.waveform_arguments,
+            frequency_domain_source_model=str(
+                self.waveform_generator.frequency_domain_source_model),
+            sampling_frequency=self.waveform_generator.sampling_frequency,
+            duration=self.waveform_generator.duration,
+            start_time=self.waveform_generator.start_time)
+
 
 class BasicGravitationalWaveTransient(likelihood.Likelihood):
 

bilby/gw/result.py

@@ -17,14 +17,33 @@ class CompactBinaryCoalesenceResult(CoreResult):
     def __get_from_nested_meta_data(self, *keys):
         dictionary = self.meta_data
         try:
+            item = None
             for k in keys:
                 item = dictionary[k]
                 dictionary = item
             return item
         except KeyError:
-            raise ValueError(
+            raise AttributeError(
                 "No information stored for {}".format('/'.join(keys)))
 
+    @property
+    def sampling_frequency(self):
+        """ Sampling frequency in Hertz"""
+        return self.__get_from_nested_meta_data(
+            'likelihood', 'sampling_frequency')
+
+    @property
+    def duration(self):
+        """ Duration in seconds """
+        return self.__get_from_nested_meta_data(
+            'likelihood', 'duration')
+
+    @property
+    def start_time(self):
+        """ Start time in seconds """
+        return self.__get_from_nested_meta_data(
+            'likelihood', 'start_time')
+
     @property
     def time_marginalization(self):
         """ Boolean for if the likelihood used time marginalization """
@@ -82,7 +101,7 @@ class CompactBinaryCoalesenceResult(CoreResult):
         try:
             return self.__get_from_nested_meta_data(
                 'likelihood', 'interferometers', detector)
-        except ValueError:
+        except AttributeError:
             logger.info("No injection for detector {}".format(detector))
             return None
 

test/gw_likelihood_test.py

@@ -147,6 +147,20 @@ class TestGWTransient(unittest.TestCase):
         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(
+            interferometers=self.interferometers.meta_data,
+            time_marginalization=False,
+            phase_marginalization=False,
+            distance_marginalization=False,
+            waveform_arguments=self.waveform_generator.waveform_arguments,
+            frequency_domain_source_model=str(
+                self.waveform_generator.frequency_domain_source_model),
+            sampling_frequency=self.waveform_generator.sampling_frequency,
+            duration=self.waveform_generator.duration,
+            start_time=self.waveform_generator.start_time)
+        self.assertDictEqual(expected, self.likelihood.meta_data)
+
 
 class TestTimeMarginalization(unittest.TestCase):
 

test/gw_result_test.py

@@ -49,8 +49,8 @@ class TestCBCResult(unittest.TestCase):
 
     def test_phase_marginalization_unset(self):
         self.result.meta_data['likelihood'].pop('phase_marginalization')
-        with self.assertRaises(ValueError):
-            self.result.phase_marginalization,
+        with self.assertRaises(AttributeError):
+            self.result.phase_marginalization
 
     def test_time_marginalization(self):
         self.assertEqual(
@@ -59,8 +59,8 @@ class TestCBCResult(unittest.TestCase):
 
     def test_time_marginalization_unset(self):
         self.result.meta_data['likelihood'].pop('time_marginalization')
-        with self.assertRaises(ValueError):
-            self.result.time_marginalization,
+        with self.assertRaises(AttributeError):
+            self.result.time_marginalization
 
     def test_distance_marginalization(self):
         self.assertEqual(
@@ -69,8 +69,8 @@ class TestCBCResult(unittest.TestCase):
 
     def test_distance_marginalization_unset(self):
         self.result.meta_data['likelihood'].pop('distance_marginalization')
-        with self.assertRaises(ValueError):
-            self.result.distance_marginalization,
+        with self.assertRaises(AttributeError):
+            self.result.distance_marginalization
 
     def test_reference_frequency(self):
         self.assertEqual(
@@ -79,8 +79,8 @@ class TestCBCResult(unittest.TestCase):
 
     def test_reference_frequency_unset(self):
         self.result.meta_data['likelihood']['waveform_arguments'].pop('reference_frequency')
-        with self.assertRaises(ValueError):
-            self.result.reference_frequency,
+        with self.assertRaises(AttributeError):
+            self.result.reference_frequency
 
     def test_waveform_approximant(self):
         self.assertEqual(
@@ -89,8 +89,8 @@ class TestCBCResult(unittest.TestCase):
 
     def test_waveform_approximant_unset(self):
         self.result.meta_data['likelihood']['waveform_arguments'].pop('waveform_approximant')
-        with self.assertRaises(ValueError):
-            self.result.waveform_approximant,
+        with self.assertRaises(AttributeError):
+            self.result.waveform_approximant
 
     def test_frequency_domain_source_model(self):
         self.assertEqual(
@@ -99,7 +99,7 @@ class TestCBCResult(unittest.TestCase):
 
     def test_frequency_domain_source_model_unset(self):
         self.result.meta_data['likelihood'].pop('frequency_domain_source_model')
-        with self.assertRaises(ValueError):
+        with self.assertRaises(AttributeError):
             self.result.frequency_domain_source_model
 
     def test_detector_injection_properties(self):