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)