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_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_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)
def test_fhf_normalised(self): norms = list() for _ in range(self.n_test): lamb = np.random.uniform(-15, 15) p_z = redshift.power_law_redshift(self.test_data, lamb) norms.append(trapz(p_z, self.zs)) self.assertAlmostEqual(xp.max(xp.abs(xp.asarray(norms) - 1)), 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_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_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.assertEquals(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)))
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_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)
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.assertEquals(0.0, xp.max( spin.iid_spin_magnitude_beta(self.test_data, **iid_params) - spin.independent_spin_magnitude_beta( self.test_data, **ind_params)))
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.assertEquals(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 _run_model_normalisation(self, model, priors): norms = list() for _ in range(self.n_test): p_z = model(self.test_data, **priors.sample()) norms.append(trapz(p_z, self.zs)) self.assertAlmostEqual(xp.max(xp.abs(xp.asarray(norms) - 1)), 0.0)
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 _max_abs_difference(array, comparison): return float(xp.max(xp.abs(comparison - xp.asarray(array))))
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)