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)