bilby/core/sampler/pymultinest.py

@@ -62,6 +62,7 @@ class Pymultinest(_TemporaryFileSamplerMixin, NestedSampler):
     )
     short_name = "pm"
     hard_exit = True
+    sampling_seed_key = "seed"
 
     def __init__(
         self,
@@ -104,6 +105,7 @@ class Pymultinest(_TemporaryFileSamplerMixin, NestedSampler):
         self.use_temporary_directory = temporary_directory and not using_mpi
 
     def _translate_kwargs(self, kwargs):
+        kwargs = super()._translate_kwargs(kwargs)
         if "n_live_points" not in kwargs:
             for equiv in self.npoints_equiv_kwargs:
                 if equiv in kwargs:

bilby/core/sampler/ultranest.py

@@ -104,6 +104,7 @@ class Ultranest(_TemporaryFileSamplerMixin, NestedSampler):
             self.callback_interval = callback_interval
 
     def _translate_kwargs(self, kwargs):
+        kwargs = super()._translate_kwargs(kwargs)
         if "num_live_points" not in kwargs:
             for equiv in self.npoints_equiv_kwargs:
                 if equiv in kwargs:

bilby/core/utils/introspection.py

@@ -94,10 +94,7 @@ def infer_args_from_function_except_n_args(func, n=1):
         ['c', 'd']
 
     """
-    try:
-        parameters = inspect.getfullargspec(func).args
-    except AttributeError:
-        parameters = inspect.getargspec(func).args
+    parameters = inspect.getfullargspec(func).args
     del parameters[:n]
     return parameters
 

bilby/core/utils/log.py

 import logging
-import os
 from pathlib import Path
 import sys
 
@@ -60,13 +59,8 @@ def setup_logger(outdir='.', label=None, log_level='INFO', print_version=False):
 
 
 def get_version_information():
-    version_file = os.path.join(
-        os.path.dirname(os.path.dirname(os.path.dirname(__file__))), '.version')
-    try:
-        with open(version_file, 'r') as f:
-            return f.readline().rstrip()
-    except EnvironmentError:
-        print("No version information file '.version' found")
+    from bilby import __version__
+    return __version__
 
 
 def loaded_modules_dict():

bilby/gw/conversion.py

@@ -1001,7 +1001,7 @@ def fill_from_fixed_priors(sample, priors):
     return output_sample
 
 
-def generate_component_masses(sample, require_add=False):
+def generate_component_masses(sample, require_add=False, source=False):
     """"
     Add the component masses to the dataframe/dictionary
     We add:
@@ -1022,6 +1022,9 @@ def generate_component_masses(sample, require_add=False):
         component with overall mass scaling (i.e.
         chirp_mass, mass_1, mass_2, total_mass) and
         then any other mass parameter.
+    source : bool, default False
+        If True, then perform the conversions for source mass parameters
+        i.e. mass_1_source instead of mass_1
 
     Returns
     dict : the updated dictionary
@@ -1032,12 +1035,24 @@ def generate_component_masses(sample, require_add=False):
         else:
             return sample
     output_sample = sample.copy()
-    if "mass_1" in sample.keys():
-        if "mass_2" in sample.keys():
+
+    if source:
+        mass_1_key = "mass_1_source"
+        mass_2_key = "mass_2_source"
+        total_mass_key = "total_mass_source"
+        chirp_mass_key = "chirp_mass_source"
+    else:
+        mass_1_key = "mass_1"
+        mass_2_key = "mass_2"
+        total_mass_key = "total_mass"
+        chirp_mass_key = "chirp_mass"
+
+    if mass_1_key in sample.keys():
+        if mass_2_key in sample.keys():
             return output_sample
-        if "total_mass" in sample.keys():
-            output_sample["mass_2"] = output_sample["total_mass"] - (
-                output_sample["mass_1"]
+        if total_mass_key in sample.keys():
+            output_sample[mass_2_key] = output_sample[total_mass_key] - (
+                output_sample[mass_1_key]
             )
             return output_sample
 
@@ -1048,26 +1063,26 @@ def generate_component_masses(sample, require_add=False):
                 symmetric_mass_ratio_to_mass_ratio(
                     output_sample["symmetric_mass_ratio"])
             )
-        elif "chirp_mass" in sample.keys():
+        elif chirp_mass_key in sample.keys():
             output_sample["mass_ratio"] = (
                 mass_1_and_chirp_mass_to_mass_ratio(
-                    mass_1=output_sample["mass_1"],
-                    chirp_mass=output_sample["chirp_mass"])
+                    mass_1=output_sample[mass_1_key],
+                    chirp_mass=output_sample[chirp_mass_key])
             )
         else:
             return check_and_return_quietly(require_add, sample)
 
-        output_sample["mass_2"] = (
-            output_sample["mass_ratio"] * output_sample["mass_1"]
+        output_sample[mass_2_key] = (
+            output_sample["mass_ratio"] * output_sample[mass_1_key]
         )
 
         return output_sample
 
-    elif "mass_2" in sample.keys():
+    elif mass_2_key in sample.keys():
         # mass_1 is not in the dict
-        if "total_mass" in sample.keys():
-            output_sample["mass_1"] = (
-                output_sample["total_mass"] - output_sample["mass_2"]
+        if total_mass_key in sample.keys():
+            output_sample[mass_1_key] = (
+                output_sample[total_mass_key] - output_sample[mass_2_key]
             )
             return output_sample
         elif "mass_ratio" in sample.keys():
@@ -1077,23 +1092,23 @@ def generate_component_masses(sample, require_add=False):
                 symmetric_mass_ratio_to_mass_ratio(
                     output_sample["symmetric_mass_ratio"])
             )
-        elif "chirp_mass" in sample.keys():
+        elif chirp_mass_key in sample.keys():
             output_sample["mass_ratio"] = (
                 mass_2_and_chirp_mass_to_mass_ratio(
-                    mass_2=output_sample["mass_2"],
-                    chirp_mass=output_sample["chirp_mass"])
+                    mass_2=output_sample[mass_2_key],
+                    chirp_mass=output_sample[chirp_mass_key])
             )
         else:
             check_and_return_quietly(require_add, sample)
 
-        output_sample["mass_1"] = 1 / output_sample["mass_ratio"] * (
-            output_sample["mass_2"]
+        output_sample[mass_1_key] = 1 / output_sample["mass_ratio"] * (
+            output_sample[mass_2_key]
         )
 
         return output_sample
 
     # Only if neither mass_1 or mass_2 is in the input sample
-    if "total_mass" in sample.keys():
+    if total_mass_key in sample.keys():
         if "mass_ratio" in sample.keys():
             pass  # We have everything we need already
         elif "symmetric_mass_ratio" in sample.keys():
@@ -1101,11 +1116,11 @@ def generate_component_masses(sample, require_add=False):
                 symmetric_mass_ratio_to_mass_ratio(
                     output_sample["symmetric_mass_ratio"])
             )
-        elif "chirp_mass" in sample.keys():
+        elif chirp_mass_key in sample.keys():
             output_sample["symmetric_mass_ratio"] = (
                 chirp_mass_and_total_mass_to_symmetric_mass_ratio(
-                    chirp_mass=output_sample["chirp_mass"],
-                    total_mass=output_sample["total_mass"])
+                    chirp_mass=output_sample[chirp_mass_key],
+                    total_mass=output_sample[total_mass_key])
             )
             output_sample["mass_ratio"] = (
                 symmetric_mass_ratio_to_mass_ratio(
@@ -1114,7 +1129,7 @@ def generate_component_masses(sample, require_add=False):
         else:
             return check_and_return_quietly(require_add, sample)
 
-    elif "chirp_mass" in sample.keys():
+    elif chirp_mass_key in sample.keys():
         if "mass_ratio" in sample.keys():
             pass
         elif "symmetric_mass_ratio" in sample.keys():
@@ -1125,27 +1140,28 @@ def generate_component_masses(sample, require_add=False):
         else:
             return check_and_return_quietly(require_add, sample)
 
-        output_sample["total_mass"] = (
+        output_sample[total_mass_key] = (
             chirp_mass_and_mass_ratio_to_total_mass(
-                chirp_mass=output_sample["chirp_mass"],
+                chirp_mass=output_sample[chirp_mass_key],
                 mass_ratio=output_sample["mass_ratio"])
         )
 
     # We haven't matched any of the criteria
-    if "total_mass" not in output_sample.keys() or (
+    if total_mass_key not in output_sample.keys() or (
             "mass_ratio" not in output_sample.keys()):
         return check_and_return_quietly(require_add, sample)
     mass_1, mass_2 = (
         total_mass_and_mass_ratio_to_component_masses(
-            total_mass=output_sample["total_mass"],
+            total_mass=output_sample[total_mass_key],
             mass_ratio=output_sample["mass_ratio"])
     )
-    output_sample["mass_1"] = mass_1
-    output_sample["mass_2"] = mass_2
+    output_sample[mass_1_key] = mass_1
+    output_sample[mass_2_key] = mass_2
+
     return output_sample
 
 
-def generate_mass_parameters(sample):
+def generate_mass_parameters(sample, source=False):
     """
     Add the known mass parameters to the data frame/dictionary.  We do
     not recompute keys already present in the dictionary
@@ -1165,27 +1181,39 @@ def generate_mass_parameters(sample):
 
     """
     # Only add the parameters if they're not already present
-    intermediate_sample = generate_component_masses(sample)
+    intermediate_sample = generate_component_masses(sample, source=source)
     output_sample = intermediate_sample.copy()
-    if "chirp_mass" not in output_sample.keys():
-        output_sample['chirp_mass'] = (
-            component_masses_to_chirp_mass(output_sample['mass_1'],
-                                           output_sample['mass_2'])
+
+    if source:
+        mass_1_key = 'mass_1_source'
+        mass_2_key = 'mass_2_source'
+        total_mass_key = 'total_mass_source'
+        chirp_mass_key = 'chirp_mass_source'
+    else:
+        mass_1_key = 'mass_1'
+        mass_2_key = 'mass_2'
+        total_mass_key = 'total_mass'
+        chirp_mass_key = 'chirp_mass'
+
+    if chirp_mass_key not in output_sample.keys():
+        output_sample[chirp_mass_key] = (
+            component_masses_to_chirp_mass(output_sample[mass_1_key],
+                                           output_sample[mass_2_key])
         )
-    if "total_mass" not in output_sample.keys():
-        output_sample['total_mass'] = (
-            component_masses_to_total_mass(output_sample['mass_1'],
-                                           output_sample['mass_2'])
+    if total_mass_key not in output_sample.keys():
+        output_sample[total_mass_key] = (
+            component_masses_to_total_mass(output_sample[mass_1_key],
+                                           output_sample[mass_2_key])
         )
-    if "symmetric_mass_ratio" not in output_sample.keys():
+    if 'symmetric_mass_ratio' not in output_sample.keys():
         output_sample['symmetric_mass_ratio'] = (
-            component_masses_to_symmetric_mass_ratio(output_sample['mass_1'],
-                                                     output_sample['mass_2'])
+            component_masses_to_symmetric_mass_ratio(output_sample[mass_1_key],
+                                                     output_sample[mass_2_key])
         )
-    if "mass_ratio" not in output_sample.keys():
+    if 'mass_ratio' not in output_sample.keys():
         output_sample['mass_ratio'] = (
-            component_masses_to_mass_ratio(output_sample['mass_1'],
-                                           output_sample['mass_2'])
+            component_masses_to_mass_ratio(output_sample[mass_1_key],
+                                           output_sample[mass_2_key])
         )
 
     return output_sample
@@ -1479,11 +1507,15 @@ def generate_posterior_samples_from_marginalized_likelihood(
         use_cache = False
 
     if use_cache and os.path.exists(cache_filename) and not command_line_args.clean:
-        with open(cache_filename, "rb") as f:
-            cached_samples_dict = pickle.load(f)
+        try:
+            with open(cache_filename, "rb") as f:
+                cached_samples_dict = pickle.load(f)
+        except EOFError:
+            logger.warning("Cache file is empty")
+            cached_samples_dict = None
 
         # Check the samples are identical between the cache and current
-        if cached_samples_dict["_samples"].equals(samples):
+        if (cached_samples_dict is not None) and (cached_samples_dict["_samples"].equals(samples)):
             # Calculate reconstruction percentage and print a log message
             nsamples_converted = np.sum(
                 [len(val) for key, val in cached_samples_dict.items() if key != "_samples"]

bilby/gw/prior.py

@@ -1183,7 +1183,7 @@ class CalibrationPriorDict(PriorDict):
     @staticmethod
     def constant_uncertainty_spline(
             amplitude_sigma, phase_sigma, minimum_frequency, maximum_frequency,
-            n_nodes, label):
+            n_nodes, label, boundary="reflective"):
         """
         Make prior assuming constant in frequency calibration uncertainty.
 
@@ -1203,6 +1203,8 @@ class CalibrationPriorDict(PriorDict):
             Number of nodes for the spline.
         label: str
             Label for the names of the parameters, e.g., `recalib_H1_`
+        boundary: None, 'reflective', 'periodic'
+            The type of prior boundary to assign
 
         Returns
         =======
@@ -1225,14 +1227,14 @@ class CalibrationPriorDict(PriorDict):
             prior[name] = Gaussian(mu=amplitude_mean_nodes[ii],
                                    sigma=amplitude_sigma_nodes[ii],
                                    name=name, latex_label=latex_label,
-                                   boundary='reflective')
+                                   boundary=boundary)
         for ii in range(n_nodes):
             name = "recalib_{}_phase_{}".format(label, ii)
             latex_label = r"$\phi^{}_{}$".format(label, ii)
             prior[name] = Gaussian(mu=phase_mean_nodes[ii],
                                    sigma=phase_sigma_nodes[ii],
                                    name=name, latex_label=latex_label,
-                                   boundary='reflective')
+                                   boundary=boundary)
         for ii in range(n_nodes):
             name = "recalib_{}_frequency_{}".format(label, ii)
             latex_label = "$f^{}_{}$".format(label, ii)

bilby/gw/prior_files/GW150914.prior

 mass_ratio = bilby.gw.prior.UniformInComponentsMassRatio(name='mass_ratio', minimum=0.125, maximum=1)
-chirp_mass = bilby.gw.prior.UniformInComponentsChirpMass(name='chirp_mass', minimum=25, maximum=31)
+chirp_mass = bilby.gw.prior.UniformInComponentsChirpMass(name='chirp_mass', minimum=25, maximum=35)
 mass_1 = Constraint(name='mass_1', minimum=10, maximum=80)
 mass_2 = Constraint(name='mass_2', minimum=10, maximum=80)
 a_1 = Uniform(name='a_1', minimum=0, maximum=0.99)

bilby/gw/waveform_generator.py

@@ -258,14 +258,16 @@ class WaveformGenerator(object):
 
 class LALCBCWaveformGenerator(WaveformGenerator):
     """ A waveform generator with specific checks for LAL CBC waveforms """
+    LAL_SIM_INSPIRAL_SPINS_FLOW = 1
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.validate_reference_frequency()
 
     def validate_reference_frequency(self):
-        from lalsimulation import SimInspiralGetSpinFreqFromApproximant, LAL_SIM_INSPIRAL_SPINS_FLOW
+        from lalsimulation import SimInspiralGetSpinFreqFromApproximant
         waveform_approximant = self.waveform_arguments["waveform_approximant"]
         waveform_approximant_number = lalsim_GetApproximantFromString(waveform_approximant)
-        if SimInspiralGetSpinFreqFromApproximant(waveform_approximant_number) == LAL_SIM_INSPIRAL_SPINS_FLOW:
+        if SimInspiralGetSpinFreqFromApproximant(waveform_approximant_number) == self.LAL_SIM_INSPIRAL_SPINS_FLOW:
             if self.waveform_arguments["reference_frequency"] != self.waveform_arguments["minimum_frequency"]:
                 raise ValueError(f"For {waveform_approximant}, reference_frequency must equal minimum_frequency")

containers/dockerfile-template

@@ -37,6 +37,7 @@ RUN conda install -n ${{conda_env}} -c conda-forge ptmcmcsampler
 RUN conda install -n ${{conda_env}} -c conda-forge pytorch
 RUN conda install -n ${{conda_env}} -c conda-forge theano-pymc
 RUN conda install -n ${{conda_env}} -c conda-forge pymc3
+RUN conda install -n ${{conda_env}} -c conda-forge pymc pymc-base
 RUN pip install nessai
 
 # Install Polychord

containers/v3-dockerfile-test-suite-python38

@@ -39,6 +39,7 @@ RUN conda install -n ${conda_env} -c conda-forge ptmcmcsampler
 RUN conda install -n ${conda_env} -c conda-forge pytorch
 RUN conda install -n ${conda_env} -c conda-forge theano-pymc
 RUN conda install -n ${conda_env} -c conda-forge pymc3
+RUN conda install -n ${conda_env} -c conda-forge pymc pymc-base
 RUN pip install nessai
 
 # Install Polychord

containers/v3-dockerfile-test-suite-python39

@@ -39,6 +39,7 @@ RUN conda install -n ${conda_env} -c conda-forge ptmcmcsampler
 RUN conda install -n ${conda_env} -c conda-forge pytorch
 RUN conda install -n ${conda_env} -c conda-forge theano-pymc
 RUN conda install -n ${conda_env} -c conda-forge pymc3
+RUN conda install -n ${conda_env} -c conda-forge pymc pymc-base
 RUN pip install nessai
 
 # Install Polychord

docs/likelihood.txt

@@ -128,9 +128,7 @@ In :code:`bilby`, we can code this up as a likelihood in the following way::
            self.function = function
 
            # These lines of code infer the parameters from the provided function
-           parameters = inspect.getargspec(function).args
-           parameters.pop(0)
-           super().__init__(parameters=dict.fromkeys(parameters))
+           super().__init__(parameters=dict())
 
 
        def log_likelihood(self):
@@ -197,10 +195,10 @@ instantiating the likelihood::
           self.function = function
 
           # These lines of code infer the parameters from the provided function
-          parameters = inspect.getargspec(function).args
-          parameters.pop(0)
+          parameters = inspect.getfullargspec(function).args
+          del parameters[0]
           super().__init__(parameters=dict.fromkeys(parameters))
-                    self.parameters = dict.fromkeys(parameters)
+          self.parameters = dict.fromkeys(parameters)
 
           self.function_keys = self.parameters.keys()
           if self.sigma is None:

pyproject.toml

+[build-system]
+requires = [
+    "setuptools>=42",
+    "setuptools_scm[toml]>=3.4.3",
+    "wheel",
+]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools_scm]
+write_to = "bilby/_version.py"
\ No newline at end of file

setup.py

 #!/usr/bin/env python
 
 from setuptools import setup
-import subprocess
 import sys
 import os
 
@@ -10,44 +9,6 @@ if python_version < (3, 8):
     sys.exit("Python < 3.8 is not supported, aborting setup")
 
 
-def write_version_file(version):
-    """Writes a file with version information to be used at run time
-
-    Parameters
-    ----------
-    version: str
-        A string containing the current version information
-
-    Returns
-    -------
-    version_file: str
-        A path to the version file
-
-    """
-    try:
-        git_log = subprocess.check_output(
-            ["git", "log", "-1", "--pretty=%h %ai"]
-        ).decode("utf-8")
-        git_diff = (
-            subprocess.check_output(["git", "diff", "."])
-            + subprocess.check_output(["git", "diff", "--cached", "."])
-        ).decode("utf-8")
-        if git_diff == "":
-            git_status = "(CLEAN) " + git_log
-        else:
-            git_status = "(UNCLEAN) " + git_log
-    except Exception as e:
-        print("Unable to obtain git version information, exception: {}".format(e))
-        git_status = "release"
-
-    version_file = ".version"
-    if os.path.isfile(version_file) is False:
-        with open("bilby/" + version_file, "w+") as f:
-            f.write("{}: {}".format(version, git_status))
-
-    return version_file
-
-
 def get_long_description():
     """Finds the README and reads in the description"""
     here = os.path.abspath(os.path.dirname(__file__))
@@ -73,8 +34,6 @@ def readfile(filename):
     return filecontents
 
 
-VERSION = '1.2.0'
-version_file = write_version_file(VERSION)
 long_description = get_long_description()
 
 setup(
@@ -86,7 +45,6 @@ setup(
     author="Greg Ashton, Moritz Huebner, Paul Lasky, Colm Talbot",
     author_email="paul.lasky@monash.edu",
     license="MIT",
-    version=VERSION,
     packages=[
         "bilby",
         "bilby.bilby_mcmc",
@@ -107,7 +65,6 @@ setup(
         "bilby.gw": ["prior_files/*"],
         "bilby.gw.detector": ["noise_curves/*.txt", "detectors/*"],
         "bilby.gw.eos": ["eos_tables/*.dat"],
-        "bilby": [version_file],
     },
     python_requires=">=3.8",
     install_requires=get_requirements(),

test/core/prior/joint_test.py

@@ -39,5 +39,61 @@ MultivariateGaussianDist(
                 )
 
 
+class TestMultivariateGaussianDistParameterScales(unittest.TestCase):
+    def _test_mvg_ln_prob_diff_expected(self, mvg, mus, sigmas, corrcoefs):
+        # the columns of the Cholesky decompsition give the directions along which
+        # the multivariate Gaussian PDF will decrease by exact differences per unit
+        # sigma; test that these are as expected
+        ln_prob_mus = mvg.ln_prob(mus)
+        d = np.linalg.cholesky(corrcoefs)
+        for i in np.ndindex(4, 4, 4):
+            ln_prob_mus_sigmas_d_i = mvg.ln_prob(mus + sigmas * (d @ i))
+            diff_ln_prob = ln_prob_mus - ln_prob_mus_sigmas_d_i
+            diff_ln_prob_expected = 0.5 * np.sum(np.array(i)**2)
+            self.assertTrue(
+                np.allclose(diff_ln_prob, diff_ln_prob_expected)
+            )
+
+    def test_mvg_unit_scales(self):
+        # test using order-unity standard deviations and correlations
+        sigmas = 0.3 * np.ones(3)
+        corrcoefs = np.identity(3)
+        mus = np.array([3, 1, 2])
+        mvg = bilby.core.prior.MultivariateGaussianDist(
+            names=['a', 'b', 'c'],
+            mus=mus,
+            sigmas=sigmas,
+            corrcoefs=corrcoefs,
+        )
+
+        self._test_mvg_ln_prob_diff_expected(mvg, mus, sigmas, corrcoefs)
+
+    def test_mvg_cw_scales(self):
+        # test using standard deviations and correlations from the
+        # inverse Fisher information matrix for the frequency/spindown
+        # parameters of a continuous wave signal
+        T = 365.25 * 86400
+        rho = 10
+        sigmas = np.array([
+            5 * np.sqrt(3) / (2 * np.pi * T * rho),
+            6 * np.sqrt(5) / (np.pi * T**2 * rho),
+            60 * np.sqrt(7) / (np.pi * T**3 * rho)
+        ])
+        corrcoefs = np.identity(3)
+        corrcoefs[0, 2] = corrcoefs[2, 0] = -np.sqrt(21) / 5
+
+        # test MultivariateGaussianDist() can handle parameters with very different scales:
+        # - f ~ 100, fd ~ 1/T, fdd ~ 1/T^2
+        mus = [123.4, -5.6e-8, 9e-18]
+        mvg = bilby.core.prior.MultivariateGaussianDist(
+            names=["f", "fd", "fdd"],
+            mus=mus,
+            sigmas=sigmas,
+            corrcoefs=corrcoefs,
+        )
+
+        self._test_mvg_ln_prob_diff_expected(mvg, mus, sigmas, corrcoefs)
+
+
 if __name__ == "__main__":
     unittest.main()

test/core/sampler/base_sampler_test.py

@@ -62,6 +62,15 @@ class TestSampler(unittest.TestCase):
     def test_label(self):
         self.assertEqual(self.sampler.label, "label")
 
+    @parameterized.expand(["sampling_seed", "seed", "random_seed"])
+    def test_translate_kwargs(self, key):
+        self.sampler.sampling_seed_key = key
+        for k in self.sampler.sampling_seed_equiv_kwargs:
+            kwargs = {k: 1234}
+            updated_kwargs = self.sampler._translate_kwargs(kwargs)
+            self.assertDictEqual(updated_kwargs, {key: 1234})
+        self.sampler.sampling_seed_key = None
+
     def test_prior_transform_transforms_search_parameter_keys(self):
         self.sampler.prior_transform([0])
         expected_prior = prior.Uniform(0, 1)

test/core/sampler/nessai_test.py

@@ -20,9 +20,11 @@ class TestNessai(unittest.TestCase):
             use_ratio=False,
             plot=False,
             skip_import_verification=True,
+            sampling_seed=150914,
         )
         self.expected = self.sampler.default_kwargs
         self.expected['output'] = 'outdir/label_nessai/'
+        self.expected['seed'] = 150914
 
     def tearDown(self):
         del self.likelihood
@@ -54,14 +56,7 @@ class TestNessai(unittest.TestCase):
             self.assertDictEqual(expected, self.sampler.kwargs)
 
     def test_translate_kwargs_seed(self):
-        expected = self.expected.copy()
-        expected["seed"] = 150914
-        for equiv in bilby.core.sampler.nessai.Nessai.seed_equiv_kwargs:
-            new_kwargs = self.sampler.kwargs.copy()
-            del new_kwargs["seed"]
-            new_kwargs[equiv] = 150914
-            self.sampler.kwargs = new_kwargs
-            self.assertDictEqual(expected, self.sampler.kwargs)
+        assert self.expected["seed"] == 150914
 
     def test_npool_max_threads(self):
         expected = self.expected.copy()

test/gw/conversion_test.py

@@ -537,17 +537,25 @@ class TestGenerateMassParameters(unittest.TestCase):
                                 'mass_2': 1.0,
                                 'chirp_mass': 1.2167286837864113,
                                 'total_mass': 3.0,
+                                'mass_1_source': 4.0,
+                                'mass_2_source': 2.0,
+                                'chirp_mass_source': 2.433457367572823,
+                                'total_mass_source': 6,
                                 'symmetric_mass_ratio': 0.2222222222222222,
                                 'mass_ratio': 0.5}
 
-    def helper_generation_from_keys(self, keys, expected_values,):
+    def helper_generation_from_keys(self, keys, expected_values, source=False):
         # Explicitly test the helper generate_component_masses
         local_test_vars = \
             {key: expected_values[key] for key in keys}
         local_test_vars_with_component_masses = \
-            conversion.generate_component_masses(local_test_vars)
-        self.assertTrue("mass_1" in local_test_vars_with_component_masses.keys())
-        self.assertTrue("mass_2" in local_test_vars_with_component_masses.keys())
+            conversion.generate_component_masses(local_test_vars, source=source)
+        if source:
+            self.assertTrue("mass_1_source" in local_test_vars_with_component_masses.keys())
+            self.assertTrue("mass_2_source" in local_test_vars_with_component_masses.keys())
+        else:
+            self.assertTrue("mass_1" in local_test_vars_with_component_masses.keys())
+            self.assertTrue("mass_2" in local_test_vars_with_component_masses.keys())
         for key in local_test_vars_with_component_masses.keys():
             self.assertAlmostEqual(
                 local_test_vars_with_component_masses[key],
@@ -555,10 +563,32 @@ class TestGenerateMassParameters(unittest.TestCase):
 
         # Test the function more generally
         local_all_mass_parameters = \
-            conversion.generate_mass_parameters(local_test_vars)
-        self.assertEqual(local_all_mass_parameters.keys(),
-                         self.expected_values.keys())
-        for key in expected_values.keys():
+            conversion.generate_mass_parameters(local_test_vars, source=source)
+        if source:
+            self.assertEqual(
+                set(local_all_mass_parameters.keys()),
+                set(["mass_1_source",
+                     "mass_2_source",
+                     "chirp_mass_source",
+                     "total_mass_source",
+                     "symmetric_mass_ratio",
+                     "mass_ratio",
+                     ]
+                    )
+            )
+        else:
+            self.assertEqual(
+                set(local_all_mass_parameters.keys()),
+                set(["mass_1",
+                     "mass_2",
+                     "chirp_mass",
+                     "total_mass",
+                     "symmetric_mass_ratio",
+                     "mass_ratio",
+                     ]
+                    )
+            )
+        for key in local_all_mass_parameters.keys():
             self.assertAlmostEqual(expected_values[key], local_all_mass_parameters[key])
 
     def test_from_mass_1_and_mass_2(self):
@@ -593,6 +623,38 @@ class TestGenerateMassParameters(unittest.TestCase):
         self.helper_generation_from_keys(["chirp_mass", "mass_2"],
                                          self.expected_values)
 
+    def test_from_mass_1_source_and_mass_2_source(self):
+        self.helper_generation_from_keys(["mass_1_source", "mass_2_source"],
+                                         self.expected_values, source=True)
+
+    def test_from_mass_1_source_and_mass_ratio(self):
+        self.helper_generation_from_keys(["mass_1_source", "mass_ratio"],
+                                         self.expected_values, source=True)
+
+    def test_from_mass_2_source_and_mass_ratio(self):
+        self.helper_generation_from_keys(["mass_2_source", "mass_ratio"],
+                                         self.expected_values, source=True)
+
+    def test_from_mass_1_source_and_total_mass(self):
+        self.helper_generation_from_keys(["mass_2_source", "total_mass_source"],
+                                         self.expected_values, source=True)
+
+    def test_from_chirp_mass_source_and_mass_ratio(self):
+        self.helper_generation_from_keys(["chirp_mass_source", "mass_ratio"],
+                                         self.expected_values, source=True)
+
+    def test_from_chirp_mass_source_and_symmetric_mass_ratio(self):
+        self.helper_generation_from_keys(["chirp_mass_source", "symmetric_mass_ratio"],
+                                         self.expected_values, source=True)
+
+    def test_from_chirp_mass_source_and_symmetric_mass_1(self):
+        self.helper_generation_from_keys(["chirp_mass_source", "mass_1_source"],
+                                         self.expected_values, source=True)
+
+    def test_from_chirp_mass_source_and_symmetric_mass_2(self):
+        self.helper_generation_from_keys(["chirp_mass_source", "mass_2_source"],
+                                         self.expected_values, source=True)
+
 
 if __name__ == "__main__":
     unittest.main()

test/gw/waveform_generator_test.py

 import unittest
 from unittest import mock
+
 import bilby
+import lalsimulation
 import numpy as np
 
 
@@ -159,6 +161,69 @@ class TestWaveformArgumentsSetting(unittest.TestCase):
         )
 
 
+class TestLALCBCWaveformArgumentsSetting(unittest.TestCase):
+    def setUp(self):
+        self.kwargs = dict(
+            duration=4,
+            frequency_domain_source_model=bilby.gw.source.lal_binary_black_hole,
+            sampling_frequency=2048,
+        )
+
+    def tearDown(self):
+        del self.kwargs
+
+    def test_spin_reference_enumeration(self):
+        """
+        Verify that the value of the reference enumerator hasn't changed by comparing
+        against a known approximant.
+        """
+        self.assertEqual(
+            lalsimulation.SimInspiralGetSpinFreqFromApproximant(lalsimulation.SEOBNRv3),
+            bilby.gw.waveform_generator.LALCBCWaveformGenerator.LAL_SIM_INSPIRAL_SPINS_FLOW,
+        )
+
+    def test_create_waveform_generator_non_precessing(self):
+        self.kwargs["waveform_arguments"] = dict(
+            minimum_frequency=20.0,
+            reference_frequency=50.0,
+            waveform_approximant="TaylorF2",
+        )
+        wfg = bilby.gw.waveform_generator.LALCBCWaveformGenerator(**self.kwargs)
+        self.assertDictEqual(
+            wfg.waveform_arguments,
+            dict(
+                minimum_frequency=20.0,
+                reference_frequency=50.0,
+                waveform_approximant="TaylorF2",
+            ),
+        )
+
+    def test_create_waveform_generator_eob_succeeds(self):
+        self.kwargs["waveform_arguments"] = dict(
+            minimum_frequency=20.0,
+            reference_frequency=20.0,
+            waveform_approximant="SEOBNRv3",
+        )
+        wfg = bilby.gw.waveform_generator.LALCBCWaveformGenerator(**self.kwargs)
+        self.assertDictEqual(
+            wfg.waveform_arguments,
+            dict(
+                minimum_frequency=20.0,
+                reference_frequency=20.0,
+                waveform_approximant="SEOBNRv3",
+            ),
+        )
+
+    def test_create_waveform_generator_eob_fails(self):
+        self.kwargs["waveform_arguments"] = dict(
+            minimum_frequency=20.0,
+            reference_frequency=50.0,
+            waveform_approximant="SEOBNRv3",
+        )
+        with self.assertRaises(ValueError):
+            _ = bilby.gw.waveform_generator.LALCBCWaveformGenerator(**self.kwargs)
+
+
 class TestSetters(unittest.TestCase):
     def setUp(self):
         self.waveform_generator = bilby.gw.waveform_generator.WaveformGenerator(