def get_m1m2_grid(m1_range, m2_range, filtering_criteria):
"""Return a meshgrid of m1, m2, z points based on filtering criteria.
The returned meshgrid can be used to create a contour plot based on the filtering
criteria
:param m1_range:
:param m2_range:
:param filtering_criteria:
:return:
"""
xs = np.linspace(m1_range[0], m1_range[1], 1000)
ys = np.linspace(m2_range[0], m2_range[1], 1000)[::-1]
m1, m2 = np.meshgrid(xs, ys)
z = np.zeros(shape=(len(xs), len(ys)))
for nrx, loop_m1 in enumerate(tqdm(xs)):
for nry, loop_m2 in enumerate(ys):
if loop_m2 > loop_m1:
pass # by definition, we choose only m2 smaller than m1
if loop_m2 < loop_m1:
mc = conversion.component_masses_to_chirp_mass(loop_m1, loop_m2)
M = conversion.component_masses_to_total_mass(loop_m1, loop_m2)
q = conversion.component_masses_to_mass_ratio(loop_m1, loop_m2)
if filtering_criteria(loop_m1, loop_m2, mc, q, M) == 1:
z[nry][nrx] = 1
return m1, m2, z
def setUp(self):
self.search_keys = []
self.parameters = dict()
self.component_mass_pars = dict(mass_1=1.4, mass_2=1.4)
self.mass_parameters = self.component_mass_pars.copy()
self.mass_parameters[
"mass_ratio"] = conversion.component_masses_to_mass_ratio(
**self.component_mass_pars)
self.mass_parameters[
"symmetric_mass_ratio"] = conversion.component_masses_to_symmetric_mass_ratio(
**self.component_mass_pars)
self.mass_parameters[
"chirp_mass"] = conversion.component_masses_to_chirp_mass(
**self.component_mass_pars)
self.mass_parameters[
"total_mass"] = conversion.component_masses_to_total_mass(
**self.component_mass_pars)
self.component_tidal_parameters = dict(lambda_1=300, lambda_2=300)
self.all_component_pars = self.component_tidal_parameters.copy()
self.all_component_pars.update(self.component_mass_pars)
self.tidal_parameters = self.component_tidal_parameters.copy()
self.tidal_parameters[
"lambda_tilde"] = conversion.lambda_1_lambda_2_to_lambda_tilde(
**self.all_component_pars)
self.tidal_parameters[
"delta_lambda_tilde"] = conversion.lambda_1_lambda_2_to_delta_lambda_tilde(
**self.all_component_pars)
def add_signal_duration(df):
df["chirp_mass"] = component_masses_to_chirp_mass(df['mass_1'],
df['mass_2'])
duration, roq_scale_factor = np.vectorize(
determine_duration_and_scale_factor_from_parameters)(
chirp_mass=df["chirp_mass"])
df["duration"] = duration
long_signals = [
f"data{i}" for i in range(len(duration)) if duration[i] > 4
]
# print(f"long_signals= " + str(long_signals).replace("'", ""))
return df
def get_m1m2_grid(m1_range, m2_range, prior, resolution):
"""Generate a grid of m1 and m2 and mark point if in prior space."""
xs = np.linspace(m1_range[0], m1_range[1], resolution)
ys = np.linspace(m2_range[0], m2_range[1], resolution)[::-1]
m1, m2 = np.meshgrid(xs, ys)
in_prior = np.zeros(shape=(len(xs), len(ys)))
for nrx, loop_m1 in enumerate(tqdm(xs)):
for nry, loop_m2 in enumerate(ys):
if loop_m2 > loop_m1:
pass # by definition, we choose only m2 smaller than m1
if loop_m2 < loop_m1:
mc = component_masses_to_chirp_mass(loop_m1, loop_m2)
q = component_masses_to_mass_ratio(loop_m1, loop_m2)
in_prior[nry][nrx] = prior.prob(
dict(chirp_mass=mc, mass_ratio=q, mass_2=loop_m2))
return m1, m2, in_prior
def get_event_status(catalogue_df):
data = []
for rowid, event in catalogue_df.iterrows():
m1 = event.mass_1_source
m2 = event.mass_2_source
mc = conversion.component_masses_to_chirp_mass(m1, m2)
M = conversion.component_masses_to_total_mass(m1, m2)
q = conversion.component_masses_to_mass_ratio(m1, m2)
data.append(
{
"event": event.commonName,
"catalog": event["catalog.shortName"],
"in_prior": contour_condition(m1, m2, mc, q, M) == 1,
"m1_source": m1,
"m2_source": m2,
"M": M,
}
)
return pd.DataFrame(data)
def convert_df_to_gwosc_df(df: pd.DataFrame) -> pd.DataFrame:
converted_df = df.copy()
# rename
converted_df['GPS'] = converted_df['tc']
converted_df['mass_1'] = converted_df['mass1']
converted_df['mass_2'] = converted_df['mass2']
converted_df[
'total_mass'] = converted_df['mass_1'] + converted_df['mass_2']
converted_df['luminosity_distance'] = converted_df['distance']
# re-parameterisation
converted_df['chirp_mass'] = component_masses_to_chirp_mass(
mass_1=converted_df['mass_1'], mass_2=converted_df['mass_2'])
for key in ['mass_1', 'mass_2', 'chirp_mass', 'total_mass']:
converted_df[f'{key}_source'] = \
converted_df[key] / (1 + converted_df[f'redshift'])
return converted_df
def SPA_time_shift(frequency_array, mass_1, mass_2, mode=(2, 2), to_order=8):
'''
Calculate t(f) of stationary phase approximation(SPA) for a special spherical harmonic mode of GW.
See (A12) in Niu, arXiv:1910.10592
Args
frequency_array: (1d array): frequency array, unit:Hz
mass_1, mass_2 (float): masses of the compact binary, unit: solar mass
mode (Tuple[int]): harmonic mode of GW, default to be (2, 2)
to_order (int): specifying to which order the SPA takes, 1-8, default to be 8
Returns
1d array: time array t(f)
'''
gamma = 0.5772
total_mass = (mass_1 + mass_2) * M_sun
chirp_mass = component_masses_to_chirp_mass(mass_1, mass_2) * M_sun
eta = component_masses_to_symmetric_mass_ratio(mass_1, mass_2)
l, m = mode
f = 2 * frequency_array / m
v = (G * total_mass * np.pi * frequency_array / c**3)**(1 / 3)
v = v.astype('float64')
tau = [1,
0,
743 / 252 + 11 / 3 * eta,
-32 / 5 * np.pi,
3058673 / 508032 + 5429 / 504 * eta + 617 / 72 * eta**2,
(-7729 / 252 + 13 / 3 * eta) * np.pi,
-10052469856691 / 23471078400 + 128 / 3 * np.pi**2 + 6848 / 105 * gamma + (3147553127 / 3048192 - 451 / 12 * np.pi**2) * eta -
15211 / 1728 * eta**2 + 25565 / 1296 *
eta**3 + 3424 / 105 * np.log(16 * v**2),
(-15419335 / 127008 - 75703 / 756 * eta + 14809 / 378 * eta**2) * np.pi]
t_shift = -5/256 * (G * chirp_mass)**(-5 / 3) * c**5 * (np.pi * f)**(-8 / 3) * \
sum([tau_i * v**i for i, tau_i in enumerate(tau[:to_order])])
t_shift = t_shift.astype('float64')
return t_shift
def test_component_masses_to_chirp_mass(self):
chirp_mass = conversion.component_masses_to_chirp_mass(self.mass_1, self.mass_2)
self.assertAlmostEqual(self.chirp_mass, chirp_mass)
