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_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_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)
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)
def compute_branching_ratio(
self,
alpha,
beta,
mmin,
mmax,
lam,
mpp,
sigpp,
alpha_chi,
beta_chi,
delta_chi,
a_max=1,
):
probability = xp.einsum(
"i,j,k->ijk",
self.first_generation_mass_ratio(
alpha=alpha,
beta=beta,
mmin=mmin,
mmax=mmax,
lam=lam,
mpp=mpp,
sigpp=sigpp,
),
first_generation_spin_magnitude_grid(
self.a_1_array,
alpha=alpha_chi,
beta=beta_chi,
delta=delta_chi,
a_max=a_max,
),
first_generation_spin_magnitude_grid(
self.a_2_array,
alpha=alpha_chi,
beta=beta_chi,
delta=delta_chi,
a_max=a_max,
),
)
branching_ratio = trapz(
trapz(
trapz(
probability * self.retention_fraction,
self.mass_ratio_array,
),
self.a_2_array,
),
self.a_1_array,
)
branching_ratio = min(branching_ratio, 1)
return branching_ratio
def _initialize_attributes(self):
self._yy /= trapz(self._yy, self.xx)
self.YY = cumtrapz(self._yy, self.xx, initial=0)
self.YY[-1] = 1
self.probability_density = Interp(self.xx, self._yy)
self.cumulative_distribution = Interp(self.xx, self.YY)
self.inverse_cumulative_distribution = Interp(self.YY, self.xx)
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 first_generation_mass_ratio(self, alpha, beta, mmin, mmax, lam, mpp,
sigpp):
first_generation_mass = two_component_primary_mass_ratio(
dataset=self.first_generation_data,
alpha=alpha,
beta=beta,
mmin=mmin,
mmax=mmax,
lam=lam,
mpp=mpp,
sigpp=sigpp,
)
return trapz(first_generation_mass, self.mass_1s, axis=0)
def first_generation_mass_ratio(self, alpha, beta, mmin, mmax, lam, mpp,
sigpp):
grid_shift = (mmin - self.mass_1s[0] - self.dm / 2) % self.dm
self.first_generation_data['mass_1'] += grid_shift
first_generation_mass = two_component_primary_mass_ratio(
dataset=self.first_generation_data,
alpha=alpha,
beta=beta,
mmin=mmin,
mmax=mmax,
lam=lam,
mpp=mpp,
sigpp=sigpp,
)
self.first_generation_data['mass_1'] -= grid_shift
return trapz(first_generation_mass, self.mass_1s, axis=0)
def low_spin_component_big_grid(spin, spin_array):
delta = xp.asarray(spin == 0).astype(float)
delta_norm = xp.asarray(spin_array == 0).astype(float)
return delta / trapz(delta_norm, spin_array)
def low_spin_component_grid(spin):
delta = xp.asarray(spin == 0).astype(float)
return delta / trapz(delta, spin)
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)
