class TestPrimaryMassRatio(unittest.TestCase):
def setUp(self):
self.m1s = np.linspace(3, 100, 1000)
self.qs = np.linspace(0.01, 1, 500)
m1s_grid, qs_grid = xp.meshgrid(self.m1s, self.qs)
self.dataset = dict(mass_1=m1s_grid, mass_ratio=qs_grid)
self.power_prior = PriorDict()
self.power_prior['alpha'] = Uniform(minimum=-4, maximum=12)
self.power_prior['beta'] = Uniform(minimum=-4, maximum=12)
self.power_prior['mmin'] = Uniform(minimum=3, maximum=10)
self.power_prior['mmax'] = Uniform(minimum=40, maximum=100)
self.gauss_prior = PriorDict()
self.gauss_prior['lam'] = Uniform(minimum=0, maximum=1)
self.gauss_prior['mpp'] = Uniform(minimum=20, maximum=60)
self.gauss_prior['sigpp'] = Uniform(minimum=0, maximum=10)
self.n_test = 10
def test_dynamic(self):
parameters = self.power_prior.sample()
parameters.update(self.gauss_prior.sample())
parameters = dict(alpha=2.0,
mmin=5.0,
mmax=45.0,
lam=0.1,
mpp=35.0,
sigpp=1.0,
beta=1.0,
branch_1=0.12,
branch_2=0.01)
prob = two_component_primary_mass_ratio_dynamical_without_spins(
dataset=self.dataset, **parameters)
self.assertTrue(
all(prob[self.dataset["mass_1"] *
self.dataset["mass_ratio"] <= parameters["mmin"]] == 0))
class TestDoublePowerLaw(unittest.TestCase):
def setUp(self):
self.m1s = np.linspace(3, 100, 1000)
self.qs = np.linspace(0.01, 1, 500)
m1s_grid, qs_grid = xp.meshgrid(self.m1s, self.qs)
self.dataset = dict(mass_1=m1s_grid, mass_ratio=qs_grid)
self.power_prior = PriorDict()
self.power_prior["alpha_1"] = Uniform(minimum=-4, maximum=12)
self.power_prior["alpha_2"] = Uniform(minimum=-4, maximum=12)
self.power_prior["beta"] = Uniform(minimum=-4, maximum=12)
self.power_prior["mmin"] = Uniform(minimum=3, maximum=10)
self.power_prior["mmax"] = Uniform(minimum=40, maximum=100)
self.power_prior["break_fraction"] = Uniform(minimum=40, maximum=100)
self.n_test = 10
def test_double_power_law_zero_below_mmin(self):
for ii in range(self.n_test):
parameters = self.power_prior.sample()
del parameters["beta"]
p_m = mass.double_power_law_primary_mass(self.m1s, **parameters)
self.assertEqual(xp.max(p_m[self.m1s <= parameters["mmin"]]), 0.0)
def test_power_law_primary_mass_ratio_zero_above_mmax(self):
for ii in range(self.n_test):
parameters = self.power_prior.sample()
p_m = mass.double_power_law_primary_power_law_mass_ratio(
self.dataset, **parameters)
self.assertEqual(
xp.max(p_m[self.dataset["mass_1"] >= parameters["mmax"]]), 0.0)
class TestIIDSpin(unittest.TestCase):
def setUp(self):
self.a_array = xp.linspace(0, 1, 1000)
self.costilts = xp.linspace(-1, 1, 1000)
self.test_data = dict(
a_1=xp.einsum("i,j->ij", self.a_array, xp.ones_like(self.a_array)),
a_2=xp.einsum("i,j->ji", self.a_array, xp.ones_like(self.a_array)),
cos_tilt_1=xp.einsum("i,j->ij", self.costilts, xp.ones_like(self.costilts)),
cos_tilt_2=xp.einsum("i,j->ji", self.costilts, xp.ones_like(self.costilts)),
)
self.prior = PriorDict(
dict(
amax=Uniform(0.3, 1),
alpha_chi=Uniform(1, 4),
beta_chi=Uniform(1, 4),
xi_spin=Uniform(0, 1),
sigma_spin=Uniform(0, 4),
)
)
self.n_test = 100
def test_iid_matches_independent(self):
params = self.prior.sample()
mag_params = {key: params[key] for key in ["amax", "alpha_chi", "beta_chi"]}
tilt_params = {key: params[key] for key in ["xi_spin", "sigma_spin"]}
self.assertEqual(
0.0,
xp.max(
spin.iid_spin(self.test_data, **params)
- spin.iid_spin_magnitude_beta(self.test_data, **mag_params)
* spin.iid_spin_orientation_gaussian_isotropic(
self.test_data, **tilt_params
)
),
)
def simulate_population_posteriors(sig1=5,
sig12=5,
number_events=10,
n_samp=50000,
fractional_sigma=1):
pop_prior = PriorDict(
dict(cos_theta_1=TruncatedNormal(mu=1,
sigma=sig1,
minimum=-1,
maximum=1),
cos_theta_12=TruncatedNormal(mu=1,
sigma=sig12,
minimum=-1,
maximum=1)))
params = pop_prior.keys()
posteriors = {p: [] for p in params}
trues = {p: [] for p in params}
for i in range(number_events):
true = pop_prior.sample()
posterior = simulate_posterior(true,
n_samples=n_samp,
fractional_sigma=1)
for p in params:
posteriors[p].append(posterior[p].values)
trues[p].append(true[p])
for p in params:
posteriors[p] = np.array(posteriors[p])
trues[p] = np.array(trues[p])
return dict(trues=trues, posteriors=posteriors)
class TestSpinMagnitude(unittest.TestCase):
def setUp(self):
self.a_array = xp.linspace(0, 1, 1000)
self.test_data = dict(
a_1=xp.einsum("i,j->ij", self.a_array, xp.ones_like(self.a_array)),
a_2=xp.einsum("i,j->ji", self.a_array, xp.ones_like(self.a_array)),
)
self.prior = PriorDict(
dict(amax=Uniform(0.3, 1),
alpha_chi=Uniform(1, 4),
beta_chi=Uniform(1, 4)))
self.n_test = 100
def tearDown(self):
del self.test_data
del self.prior
del self.a_array
del self.n_test
def test_spin_magnitude_normalised(self):
norms = list()
for ii in range(self.n_test):
parameters = self.prior.sample()
temp = spin.iid_spin_magnitude_beta(self.test_data, **parameters)
norms.append(trapz(trapz(temp, self.a_array), self.a_array))
self.assertAlmostEqual(float(xp.max(xp.abs(1 - xp.asarray(norms)))), 0,
1)
def test_returns_zero_alpha_beta_less_zero(self):
parameters = self.prior.sample()
for key in ["alpha_chi", "beta_chi"]:
parameters[key] = -1
self.assertEqual(
spin.iid_spin_magnitude_beta(self.test_data, **parameters), 0)
def test_iid_matches_independent_magnitudes(self):
iid_params = self.prior.sample()
ind_params = dict()
ind_params.update({key + "_1": iid_params[key] for key in iid_params})
ind_params.update({key + "_2": iid_params[key] for key in iid_params})
self.assertEqual(
0.0,
xp.max(
spin.iid_spin_magnitude_beta(self.test_data, **iid_params) -
spin.independent_spin_magnitude_beta(self.test_data, **
ind_params)),
)
class TestPrimarySecondary(unittest.TestCase):
def setUp(self):
self.ms = np.linspace(3, 100, 1000)
self.dm = self.ms[1] - self.ms[0]
m1s_grid, m2s_grid = xp.meshgrid(self.ms, self.ms)
self.dataset = dict(mass_1=m1s_grid, mass_2=m2s_grid)
self.power_prior = PriorDict()
self.power_prior["alpha"] = Uniform(minimum=-4, maximum=12)
self.power_prior["beta"] = Uniform(minimum=-4, maximum=12)
self.power_prior["mmin"] = Uniform(minimum=3, maximum=10)
self.power_prior["mmax"] = Uniform(minimum=40, maximum=100)
self.gauss_prior = PriorDict()
self.gauss_prior["lam"] = Uniform(minimum=0, maximum=1)
self.gauss_prior["mpp"] = Uniform(minimum=20, maximum=60)
self.gauss_prior["sigpp"] = Uniform(minimum=0, maximum=10)
self.n_test = 10
def test_power_law_primary_secondary_zero_below_mmin(self):
for ii in range(self.n_test):
parameters = self.power_prior.sample()
p_m = mass.power_law_primary_secondary_independent(
self.dataset, **parameters
)
self.assertEqual(
xp.max(p_m[self.dataset["mass_2"] <= parameters["mmin"]]), 0.0
)
def test_power_law_primary_secondary_zero_above_mmax(self):
for ii in range(self.n_test):
parameters = self.power_prior.sample()
del parameters["beta"]
p_m = mass.power_law_primary_secondary_identical(self.dataset, **parameters)
self.assertEqual(
xp.max(p_m[self.dataset["mass_1"] >= parameters["mmax"]]), 0.0
)
def test_two_component_primary_secondary_zero_below_mmin(self):
for ii in range(self.n_test):
parameters = self.power_prior.sample()
parameters.update(self.gauss_prior.sample())
del parameters["beta"]
p_m = mass.two_component_primary_secondary_identical(
self.dataset, **parameters
)
self.assertEqual(
xp.max(p_m[self.dataset["mass_2"] <= parameters["mmin"]]), 0.0
)
class TestSmoothedMassDistribution(unittest.TestCase):
def setUp(self):
self.m1s = np.linspace(3, 100, 1000)
self.qs = np.linspace(0.01, 1, 500)
self.dm = self.m1s[1] - self.m1s[0]
self.dq = self.qs[1] - self.qs[0]
m1s_grid, qs_grid = xp.meshgrid(self.m1s, self.qs)
self.dataset = dict(mass_1=m1s_grid, mass_ratio=qs_grid)
self.power_prior = PriorDict()
self.power_prior['alpha'] = Uniform(minimum=-4, maximum=12)
self.power_prior['beta'] = Uniform(minimum=-4, maximum=12)
self.power_prior['mmin'] = Uniform(minimum=3, maximum=10)
self.power_prior['mmax'] = Uniform(minimum=30, maximum=100)
self.gauss_prior = PriorDict()
self.gauss_prior['lam'] = Uniform(minimum=0, maximum=1)
self.gauss_prior['mpp'] = Uniform(minimum=20, maximum=60)
self.gauss_prior['sigpp'] = Uniform(minimum=0, maximum=10)
self.smooth_prior = PriorDict()
self.smooth_prior['delta_m'] = Uniform(minimum=0, maximum=10)
self.n_test = 10
def test_delta_m_zero_matches_two_component_primary_mass_ratio(self):
max_diffs = list()
for ii in range(self.n_test):
parameters = self.power_prior.sample()
parameters.update(self.gauss_prior.sample())
p_m1 = mass.two_component_primary_mass_ratio(
self.dataset, **parameters)
parameters['delta_m'] = 0
p_m2 = mass.smoothed_two_component_primary_mass_ratio(
self.dataset, **parameters)
max_diffs.append(_max_abs_difference(p_m1, p_m2))
self.assertAlmostEqual(max(max_diffs), 0.0)
def test_normalised(self):
norms = list()
for ii in range(self.n_test):
parameters = self.power_prior.sample()
parameters.update(self.gauss_prior.sample())
parameters.update(self.smooth_prior.sample())
p_m = mass.smoothed_two_component_primary_mass_ratio(
self.dataset, **parameters)
norms.append(trapz(trapz(p_m, self.m1s), self.qs))
self.assertAlmostEqual(_max_abs_difference(norms, 1.0), 0.0, 2)
class TestPrimaryMassRatio(unittest.TestCase):
def setUp(self):
self.m1s = np.linspace(3, 100, 1000)
self.qs = np.linspace(0.01, 1, 500)
m1s_grid, qs_grid = xp.meshgrid(self.m1s, self.qs)
self.dataset = dict(mass_1=m1s_grid, mass_ratio=qs_grid)
self.power_prior = PriorDict()
self.power_prior['alpha'] = Uniform(minimum=-4, maximum=12)
self.power_prior['beta'] = Uniform(minimum=-4, maximum=12)
self.power_prior['mmin'] = Uniform(minimum=3, maximum=10)
self.power_prior['mmax'] = Uniform(minimum=40, maximum=100)
self.gauss_prior = PriorDict()
self.gauss_prior['lam'] = Uniform(minimum=0, maximum=1)
self.gauss_prior['mpp'] = Uniform(minimum=20, maximum=60)
self.gauss_prior['sigpp'] = Uniform(minimum=0, maximum=10)
self.n_test = 10
def test_power_law_primary_mass_ratio_zero_below_mmin(self):
m2s = self.dataset['mass_1'] * self.dataset['mass_ratio']
for ii in range(self.n_test):
parameters = self.power_prior.sample()
p_m = mass.power_law_primary_mass_ratio(self.dataset, **parameters)
self.assertEqual(xp.max(p_m[m2s <= parameters['mmin']]), 0.0)
def test_power_law_primary_mass_ratio_zero_above_mmax(self):
for ii in range(self.n_test):
parameters = self.power_prior.sample()
p_m = mass.power_law_primary_mass_ratio(self.dataset, **parameters)
self.assertEqual(
xp.max(p_m[self.dataset['mass_1'] >= parameters['mmax']]), 0.0)
def test_two_component_primary_mass_ratio_zero_below_mmin(self):
m2s = self.dataset['mass_1'] * self.dataset['mass_ratio']
for ii in range(self.n_test):
parameters = self.power_prior.sample()
parameters.update(self.gauss_prior.sample())
p_m = mass.two_component_primary_mass_ratio(
self.dataset, **parameters)
self.assertEqual(xp.max(p_m[m2s <= parameters['mmin']]), 0.0)
def test_resampling_posteriors(self):
priors = PriorDict(
dict(a=Uniform(0, 2), b=Uniform(0, 2), c=Uniform(0, 2)))
samples = priors.sample(100)
like = HyperparameterLikelihood(
posteriors=self.data,
hyper_prior=self.model,
selection_function=self.selection_function,
ln_evidences=self.ln_evidences,
)
new_samples = like.posterior_predictive_resample(samples=samples)
for key in new_samples:
self.assertEqual(new_samples[key].shape, like.data[key].shape)
def simulate_exact_population_posteriors(sig1=5,
sig12=5,
number_events=10,
n_samp=10000):
pop_prior = PriorDict(
dict(cos_tilt_1=TruncatedNormal(mu=1,
sigma=sig1,
minimum=-1,
maximum=1),
cos_theta_12=TruncatedNormal(mu=1,
sigma=sig12,
minimum=-1,
maximum=1)))
posteriors = [pop_prior.sample(n_samp) for _ in range(number_events)]
posteriors = ld_to_dl(posteriors)
posteriors = {k: np.array(v) for k, v in posteriors.items()}
return dict(trues=[], posteriors=posteriors)
class TestSpinOrientation(unittest.TestCase):
def setUp(self):
self.costilts = xp.linspace(-1, 1, 1000)
self.test_data = dict(
cos_tilt_1=xp.einsum("i,j->ij", self.costilts,
xp.ones_like(self.costilts)),
cos_tilt_2=xp.einsum("i,j->ji", self.costilts,
xp.ones_like(self.costilts)),
)
self.prior = PriorDict(
dict(xi_spin=Uniform(0, 1), sigma_spin=Uniform(0, 4)))
self.n_test = 100
def tearDown(self):
del self.test_data
del self.prior
del self.costilts
del self.n_test
def test_spin_orientation_normalised(self):
norms = list()
for ii in range(self.n_test):
parameters = self.prior.sample()
temp = spin.iid_spin_orientation_gaussian_isotropic(
self.test_data, **parameters)
norms.append(trapz(trapz(temp, self.costilts), self.costilts))
self.assertAlmostEqual(float(xp.max(xp.abs(1 - xp.asarray(norms)))), 0,
5)
def test_iid_matches_independent_tilts(self):
iid_params = dict(xi_spin=0.5, sigma_spin=0.5)
ind_params = dict(xi_spin=0.5, sigma_1=0.5, sigma_2=0.5)
self.assertEqual(
0.0,
xp.max(
spin.iid_spin_orientation_gaussian_isotropic(
self.test_data, **iid_params) -
spin.independent_spin_orientation_gaussian_isotropic(
self.test_data, **ind_params)),
)
# Transform posterior samples
posterior_samples = transformed_samples(lal_posterior_samples)
# Read the LALInference prior
lal_prior_samples = {
list(bilby_to_lalinference.keys())[list(
bilby_to_lalinference.values()).index(key)]: lal['prior'][key]
for key in bilby_to_lalinference.values()
}
prior_length = len(lal_prior_samples['mass_1'])
# Set up the bilby prior
bilby_prior_dict = PriorDict(
filename=args.prior_path,
conversion_function=convert_to_lal_binary_black_hole_parameters)
bilby_prior_samples = pd.DataFrame(bilby_prior_dict.sample(prior_length))
# Set up the bilby mock-LALInference prior
mock_lal_prior_dict = PriorDict(filename=args.lalinference_mock_prior_path,
conversion_function=generate_mass_parameters)
mock_lal_prior_samples = pd.DataFrame(mock_lal_prior_dict.sample(prior_length))
# Store weights in a dictionary
weights = sample_weights(posterior_samples, mock_lal_prior_dict,
bilby_prior_dict)
# Apply the Jacobian if required
if args.apply_jacobian == True:
weights = np.multiply(weights, jacobian(posterior_samples))
lal_result_object = CBCResult(
label='reweighted_lalinference',
class TestSmoothedMassDistribution(unittest.TestCase):
def setUp(self):
self.m1s = np.linspace(2, 100, 1000)
self.qs = np.linspace(0.01, 1, 500)
self.dm = self.m1s[1] - self.m1s[0]
self.dq = self.qs[1] - self.qs[0]
m1s_grid, qs_grid = xp.meshgrid(self.m1s, self.qs)
self.dataset = dict(mass_1=m1s_grid, mass_ratio=qs_grid)
self.power_prior = PriorDict()
self.power_prior["alpha"] = Uniform(minimum=-4, maximum=12)
self.power_prior["beta"] = Uniform(minimum=-4, maximum=12)
self.power_prior["mmin"] = Uniform(minimum=3, maximum=10)
self.power_prior["mmax"] = Uniform(minimum=30, maximum=100)
self.gauss_prior = PriorDict()
self.gauss_prior["lam"] = Uniform(minimum=0, maximum=1)
self.gauss_prior["mpp"] = Uniform(minimum=20, maximum=60)
self.gauss_prior["sigpp"] = Uniform(minimum=0, maximum=10)
self.double_gauss_prior = PriorDict()
self.double_gauss_prior["lam"] = Uniform(minimum=0, maximum=1)
self.double_gauss_prior["lam_1"] = Uniform(minimum=0, maximum=1)
self.double_gauss_prior["mpp_1"] = Uniform(minimum=20, maximum=60)
self.double_gauss_prior["mpp_2"] = Uniform(minimum=20, maximum=60)
self.double_gauss_prior["sigpp_1"] = Uniform(minimum=0, maximum=10)
self.double_gauss_prior["sigpp_2"] = Uniform(minimum=0, maximum=10)
self.broken_power_prior = PriorDict()
self.broken_power_prior["alpha_1"] = Uniform(minimum=-4, maximum=12)
self.broken_power_prior["alpha_2"] = Uniform(minimum=-4, maximum=12)
self.broken_power_prior["break_fraction"] = Uniform(minimum=0,
maximum=1)
self.broken_power_prior["beta"] = Uniform(minimum=-4, maximum=12)
self.broken_power_prior["mmin"] = Uniform(minimum=3, maximum=10)
self.broken_power_prior["mmax"] = Uniform(minimum=30, maximum=100)
self.broken_power_peak_prior = PriorDict()
self.broken_power_peak_prior["alpha_1"] = Uniform(minimum=-4,
maximum=12)
self.broken_power_peak_prior["alpha_2"] = Uniform(minimum=-4,
maximum=12)
self.broken_power_peak_prior["break_fraction"] = Uniform(minimum=0,
maximum=1)
self.broken_power_peak_prior["beta"] = Uniform(minimum=-4, maximum=12)
self.broken_power_peak_prior["mmin"] = Uniform(minimum=3, maximum=10)
self.broken_power_peak_prior["mmax"] = Uniform(minimum=30, maximum=100)
self.broken_power_peak_prior["lam"] = Uniform(minimum=0, maximum=1)
self.broken_power_peak_prior["mpp"] = Uniform(minimum=20, maximum=60)
self.broken_power_peak_prior["sigpp"] = Uniform(minimum=0, maximum=10)
self.smooth_prior = PriorDict()
self.smooth_prior["delta_m"] = Uniform(minimum=0, maximum=10)
self.n_test = 10
def test_single_peak_delta_m_zero_matches_two_component_primary_mass_ratio(
self):
max_diffs = list()
for ii in range(self.n_test):
parameters = self.power_prior.sample()
parameters.update(self.gauss_prior.sample())
p_m1 = mass.two_component_primary_mass_ratio(
self.dataset, **parameters)
parameters["delta_m"] = 0
p_m2 = mass.SinglePeakSmoothedMassDistribution()(self.dataset,
**parameters)
max_diffs.append(_max_abs_difference(p_m1, p_m2))
self.assertAlmostEqual(max(max_diffs), 0.0)
def test_double_peak_delta_m_zero_matches_two_component_primary_mass_ratio(
self):
max_diffs = list()
for ii in range(self.n_test):
parameters = self.power_prior.sample()
parameters.update(self.double_gauss_prior.sample())
del parameters["beta"]
p_m1 = mass.three_component_single(mass=self.dataset["mass_1"],
**parameters)
parameters["delta_m"] = 0
p_m2 = mass.MultiPeakSmoothedMassDistribution().p_m1(
self.dataset, **parameters)
max_diffs.append(_max_abs_difference(p_m1, p_m2))
self.assertAlmostEqual(max(max_diffs), 0.0)
def test_single_peak_normalised(self):
norms = list()
for ii in range(self.n_test):
parameters = self.power_prior.sample()
parameters.update(self.gauss_prior.sample())
parameters.update(self.smooth_prior.sample())
p_m = mass.SinglePeakSmoothedMassDistribution()(self.dataset,
**parameters)
norms.append(trapz(trapz(p_m, self.m1s), self.qs))
self.assertAlmostEqual(_max_abs_difference(norms, 1.0), 0.0, 2)
def test_double_peak_normalised(self):
norms = list()
for ii in range(self.n_test):
parameters = self.power_prior.sample()
parameters.update(self.double_gauss_prior.sample())
parameters.update(self.smooth_prior.sample())
p_m = mass.MultiPeakSmoothedMassDistribution()(self.dataset,
**parameters)
norms.append(trapz(trapz(p_m, self.m1s), self.qs))
self.assertAlmostEqual(_max_abs_difference(norms, 1.0), 0.0, 2)
def test_broken_power_law_normalised(self):
norms = list()
for ii in range(self.n_test):
parameters = self.broken_power_prior.sample()
parameters.update(self.smooth_prior.sample())
p_m = mass.BrokenPowerLawSmoothedMassDistribution()(self.dataset,
**parameters)
norms.append(trapz(trapz(p_m, self.m1s), self.qs))
self.assertAlmostEqual(_max_abs_difference(norms, 1.0), 0.0, 2)
def test_broken_power_law_peak_normalised(self):
norms = list()
for ii in range(self.n_test):
parameters = self.broken_power_peak_prior.sample()
parameters.update(self.smooth_prior.sample())
p_m = mass.BrokenPowerLawPeakSmoothedMassDistribution()(
self.dataset, **parameters)
norms.append(trapz(trapz(p_m, self.m1s), self.qs))
self.assertAlmostEqual(_max_abs_difference(norms, 1.0), 0.0, 2)
