def get_wf_pols(file, mtotal, inclination=0.0, delta_t=1./1024, f_lower=30,
distance=100):
"""
Generate the NR_hdf5_pycbc waveform from the HDF5 file <file> with specified
params
"""
f = h5py.File(file, 'r')
# Metadata parameters:
params = {}
params['mtotal'] = mtotal
params['eta'] = f.attrs['eta']
params['mass1'] = pnutils.mtotal_eta_to_mass1_mass2(params['mtotal'], params['eta'])[0]
params['mass2'] = pnutils.mtotal_eta_to_mass1_mass2(params['mtotal'], params['eta'])[1]
params['spin1x'] = f.attrs['spin1x']
params['spin1y'] = f.attrs['spin1y']
params['spin1z'] = f.attrs['spin1z']
params['spin2x'] = f.attrs['spin2x']
params['spin2y'] = f.attrs['spin2y']
params['spin2z'] = f.attrs['spin2z']
params['coa_phase'] = f.attrs['coa_phase']
f.close()
hp, hc = get_td_waveform(approximant='NR_hdf5_pycbc',
numrel_data=file,
mass1=params['mass1'],
mass2=params['mass2'],
spin1x=params['spin1x'],
spin1y=params['spin1y'],
spin1z=params['spin1z'],
spin2x=params['spin2x'],
spin2y=params['spin2y'],
spin2z=params['spin2z'],
delta_t=delta_t,
f_lower=f_lower,
inclination=inclination,
coa_phase=params['coa_phase'],
distance=distance)
hp_tapered = wfutils.taper_timeseries(hp, 'TAPER_START')
hc_tapered = wfutils.taper_timeseries(hc, 'TAPER_START')
return hp_tapered, hc_tapered
def generator_mtotal_eta_to_mass1_mass2(generator):
"""Converts mtotal and eta in `current_params`, to mass1 and mass2.
"""
mtotal = generator.current_params['mtotal']
eta = generator.current_params['eta']
m1, m2 = pnutils.mtotal_eta_to_mass1_mass2(mtotal, eta)
generator.current_params['mass1'] = m1
generator.current_params['mass2'] = m2
def generator_mtotal_eta_to_mass1_mass2(generator):
"""Converts mtotal and eta in `current_params`, to mass1 and mass2.
"""
mtotal = generator.current_params['mtotal']
eta = generator.current_params['eta']
m1, m2 = pnutils.mtotal_eta_to_mass1_mass2(mtotal, eta)
generator.current_params['mass1'] = m1
generator.current_params['mass2'] = m2
def uniform_in_totalmass_massratio_masses(N, mtotal_min, mtotal_max, q_min,
q_max):
from pycbc.pnutils import mtotal_eta_to_mass1_mass2
from gwnr.waveform.parameters import q_to_eta
mtotal_samples = uniform_bound(mtotal_min, mtotal_max, N)
q_samples = uniform_bound(q_min, q_max, N)
return mtotal_eta_to_mass1_mass2(mtotal_samples, q_to_eta(q_samples))
def find_max_and_min_frequencies(name, mass_range_params, freqs):
"""
ADD DOCS
"""
cutoff_fns = pnutils.named_frequency_cutoffs
if name not in cutoff_fns.keys():
err_msg = "%s not recognized as a valid cutoff frequency choice." %name
err_msg += "Recognized choices: " + " ".join(cutoff_fns.keys())
raise ValueError(err_msg)
# Can I do this quickly?
total_mass_approxs = {
"SchwarzISCO": pnutils.f_SchwarzISCO,
"LightRing" : pnutils.f_LightRing,
"ERD" : pnutils.f_ERD
}
if name in total_mass_approxs.keys():
# This can be done quickly if the cutoff only depends on total mass
# Assumes that lower total mass = higher cutoff frequency
upper_f_cutoff = total_mass_approxs[name](mass_range_params.minTotMass)
lower_f_cutoff = total_mass_approxs[name](mass_range_params.maxTotMass)
else:
# Do this numerically
# FIXME: Is 1000000 the right choice? I think so, but just highlighting
tot_mass, eta, _, _, _, spin1z, spin2z = \
get_random_mass(1000000, mass_range_params)
mass1, mass2 = pnutils.mtotal_eta_to_mass1_mass2(tot_mass, eta)
mass_dict = {}
mass_dict['m1'] = mass1
mass_dict['m2'] = mass2
mass_dict['s1z'] = spin1z
mass_dict['s2z'] = spin2z
tmp_freqs = cutoff_fns[name](mass_dict)
upper_f_cutoff = tmp_freqs.max()
lower_f_cutoff = tmp_freqs.min()
cutoffs = numpy.array([lower_f_cutoff,upper_f_cutoff])
if lower_f_cutoff < freqs.min():
warn_msg = "WARNING: "
warn_msg += "Lowest frequency cutoff is %s Hz " %(lower_f_cutoff,)
warn_msg += "which is lower than the lowest frequency calculated "
warn_msg += "for the metric: %s Hz. " %(freqs.min())
warn_msg += "Distances for these waveforms will be calculated at "
warn_msg += "the lowest available metric frequency."
logging.warn(warn_msg)
if upper_f_cutoff > freqs.max():
warn_msg = "WARNING: "
warn_msg += "Highest frequency cutoff is %s Hz " %(upper_f_cutoff,)
warn_msg += "which is larger than the highest frequency calculated "
warn_msg += "for the metric: %s Hz. " %(freqs.max())
warn_msg += "Distances for these waveforms will be calculated at "
warn_msg += "the largest available metric frequency."
logging.warn(warn_msg)
return find_closest_calculated_frequencies(cutoffs, freqs)
def find_max_and_min_frequencies(name, mass_range_params, freqs):
"""
ADD DOCS
"""
cutoff_fns = pnutils.named_frequency_cutoffs
if name not in cutoff_fns.keys():
err_msg = "%s not recognized as a valid cutoff frequency choice." % name
err_msg += "Recognized choices: " + " ".join(cutoff_fns.keys())
raise ValueError(err_msg)
# Can I do this quickly?
total_mass_approxs = {
"SchwarzISCO": pnutils.f_SchwarzISCO,
"LightRing": pnutils.f_LightRing,
"ERD": pnutils.f_ERD
}
if name in total_mass_approxs.keys():
# This can be done quickly if the cutoff only depends on total mass
# Assumes that lower total mass = higher cutoff frequency
upper_f_cutoff = total_mass_approxs[name](mass_range_params.minTotMass)
lower_f_cutoff = total_mass_approxs[name](mass_range_params.maxTotMass)
else:
# Do this numerically
# FIXME: Is 1000000 the right choice? I think so, but just highlighting
tot_mass, eta, _, _, _, spin1z, spin2z = \
get_random_mass(1000000, mass_range_params)
mass1, mass2 = pnutils.mtotal_eta_to_mass1_mass2(tot_mass, eta)
mass_dict = {}
mass_dict['m1'] = mass1
mass_dict['m2'] = mass2
mass_dict['s1z'] = spin1z
mass_dict['s2z'] = spin2z
tmp_freqs = cutoff_fns[name](mass_dict)
upper_f_cutoff = tmp_freqs.max()
lower_f_cutoff = tmp_freqs.min()
cutoffs = numpy.array([lower_f_cutoff, upper_f_cutoff])
if lower_f_cutoff < freqs.min():
warn_msg = "WARNING: "
warn_msg += "Lowest frequency cutoff is %s Hz " % (lower_f_cutoff, )
warn_msg += "which is lower than the lowest frequency calculated "
warn_msg += "for the metric: %s Hz. " % (freqs.min())
warn_msg += "Distances for these waveforms will be calculated at "
warn_msg += "the lowest available metric frequency."
logging.warn(warn_msg)
if upper_f_cutoff > freqs.max():
warn_msg = "WARNING: "
warn_msg += "Highest frequency cutoff is %s Hz " % (upper_f_cutoff, )
warn_msg += "which is larger than the highest frequency calculated "
warn_msg += "for the metric: %s Hz. " % (freqs.max())
warn_msg += "Distances for these waveforms will be calculated at "
warn_msg += "the largest available metric frequency."
logging.warn(warn_msg)
return find_closest_calculated_frequencies(cutoffs, freqs)
def log_prob_enigma(theta,
inputs,
f_lower,
sampling_params,
psd,
dilation_map_match=False,
verbose=False,
ignore_samples_for=[]):
'''
Inputs:
-------
theta: (11) mass1, mass2, PNO, a1, a2, a3, a4, b1, b2, b3, b4
(11) q, mtotal,PNO, a1, a2, a3, a4, b1, b2, b3, b4
(11) eta, mtotal,PNO, a1, a2, a3, a4, b1, b2, b3, b4
inputs: pandas.core.series.Series
Attributes should include ('f_lower', 'sample_rate')
psd: pycbc.FrequencySeries
'''
# Ordering is enforced here
q, total_mass, PNO = theta[:3]
coeffs = theta[3:]
eta = q / (1. + q)**2
mass1, mass2 = pnu.mtotal_eta_to_mass1_mass2(total_mass, eta)
# Ignore sampling of certain parameters
# mass1, mass2 = prior.sample(['mass1', 'mass2'])
# if len(ignore_samples_for) > 0:
# for p in ignore_samples_for:
# p = prior.sample(p)
# Evaluate attachment freq from coefficients a1-a4 and b2-b4
fit = FitMOmegaIMRAttachmentNonSpinning()
m_omega_attach = fit.fit_ratio_poly_44(eta, coeffs)
# prior probability
log_prior = log_prior_enigma(q, total_mass, PNO, coeffs, m_omega_attach,
sampling_params, 'fit_ratio_poly_44')
if not np.isfinite(log_prior):
return log_prior
# posterior = likelihood x prior
return log_likelihood_enigma(
mass1,
mass2,
m_omega_attach,
PNO,
f_lower,
inputs.sample_rate,
psd,
dilation_map_match=dilation_map_match) + log_prior
f = h5py.File(file, 'r')
params = {}
# Extrinsic parameters:
params['f_lower'] = 20.0
params['mtotal'] = 150.0
params['inclination'] = 0.0
params['distance'] = 100.0
# Metadata parameters:
params['eta'] = f.attrs['eta']
params['mass1'] = pnutils.mtotal_eta_to_mass1_mass2(params['mtotal'], params['eta'])[0]
params['mass2'] = pnutils.mtotal_eta_to_mass1_mass2(params['mtotal'], params['eta'])[1]
params['spin1x'] = f.attrs['spin1x']
params['spin1y'] = f.attrs['spin1y']
params['spin1z'] = f.attrs['spin1z']
params['spin2x'] = f.attrs['spin2x']
params['spin2y'] = f.attrs['spin2y']
params['spin2z'] = f.attrs['spin2z']
params['coa_phase'] = f.attrs['coa_phase']
f.close()
#
dt = 1.0/4096.0
filename = simulations.simulations[sim_number]['wavefile'].split('/')[-1]
asd_data = np.loadtxt(asd_file)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Match Calculation & plotting
#
print "Extracting and generating waveform"
mass = simulations.simulations[sim_number]['Mmin30Hz']
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Common params
mass1, mass2 = pnutils.mtotal_eta_to_mass1_mass2(mass,
simulations.simulations[sim_number]['eta'])
# Estimate ffinal
chi = pnutils.phenomb_chi(mass1, mass2,
simulations.simulations[sim_number]['spin1z'],simulations.simulations[sim_number]['spin2z'])
ffinal = pnutils.get_final_freq(approx, mass1, mass2,
simulations.simulations[sim_number]['spin1z'],simulations.simulations[sim_number]['spin2z'])
#upp_bound = ffinal
#upp_bound = 1.5*ffinal
upp_bound = 0.5/delta_t
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# NUMERICAL RELATIVITY
# --- Generate the polarisations
hplus_NR, hcross_NR = nrbu.get_wf_pols(
# Set up the Masses we're going to study
masses = np.linspace(simulations.simulations[0]["Mmin30Hz"], maxMass, nMassPoints) # + 5
# matches is going to be a list of tuples: (mass, match)
matches = []
f, ax = pl.subplots(nrows=len(masses), ncols=2, figsize=(15, 15))
for m, mass in enumerate(masses):
"Extracting and generating mass %d of %d (%.2f)" % (m, len(masses), mass)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Common params
# mass = masses[-1]
mass1, mass2 = pnutils.mtotal_eta_to_mass1_mass2(mass, simulations.simulations[0]["eta"])
# Estimate ffinal
ffinal = pnutils.get_final_freq(
"SEOBNRv2", mass1, mass2, simulations.simulations[0]["spin1z"], simulations.simulations[0]["spin2z"]
)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# NUMERICAL RELATIVITY
if errors_file is None:
# --- Generate the polarisations from hdf5
hplus_NR, hcross_NR = nrbu.get_wf_pols(
simulations.simulations[0]["wavefile"],
mass,
import timeit
then = timeit.time.time()
file = '/home/jclark308/GW150914_data/nr_catalog/gatech_hdf5/GATECH0006.h5'
f = h5py.File(file, 'r')
params = {}
# Metadata parameters:
params['mtotal'] = float(sys.argv[1])
params['eta'] = f.attrs['eta']
params['mass1'] = pnutils.mtotal_eta_to_mass1_mass2(params['mtotal'], params['eta'])[0]
params['mass2'] = pnutils.mtotal_eta_to_mass1_mass2(params['mtotal'], params['eta'])[1]
params['spin1x'] = f.attrs['spin1x']
params['spin1y'] = f.attrs['spin1y']
params['spin1z'] = f.attrs['spin1z']
params['spin2x'] = f.attrs['spin2x']
params['spin2y'] = f.attrs['spin2y']
params['spin2z'] = f.attrs['spin2z']
params['coa_phase'] = f.attrs['coa_phase']
f.close()
hp, hc = get_td_waveform(approximant='NR_hdf5_pycbc',
numrel_data=file,
def log_prob_enigma_fixed_total_mass_hidden_q(theta,
inputs,
f_lower,
all_params,
psd,
omega_fit_tag,
dilation_map_match=False,
verbose=False):
'''
Inputs:
-------
theta: (11) PNO, a1, a2, a3, a4, b1, b2, b3, b4
inputs: pandas.core.series.Series
Attributes should include ('f_lower', 'sample_rate')
psd: pycbc.FrequencySeries
'''
# all_params has ordered sampler_params
# __ranges_of_sampled_params__ [omega_fit_tag] has ALL ordered sampler params
# Ordering is enforced here
PNO = theta[0]
coeffs = theta[1:]
# Sample mass ratio using information stored in the sampling_params obj
hidden_params = all_params[all_params.columns[[
all_params[c].vartype == 'hidden' for c in all_params
]]]
oned_sampler = OneDRandom(hidden_params)
q = oned_sampler.sample('q')
# Get fixed value of total mass
total_mass = float(all_params['total_mass'].range[0])
# Set other mass parameters
eta = q / (1. + q)**2
mass1, mass2 = pnu.mtotal_eta_to_mass1_mass2(total_mass, eta)
# Evaluate attachment freq from coefficients a1-a4 and b2-b4
try:
m_omega_attach = eval('fit.{}(eta, coeffs)'.format(omega_fit_tag))
except:
logging.warn("Fit tag {} not recognized.".format(omega_fit_tag))
raise
# prior probability
if np.random.uniform() < 0.01:
debug = True
else:
debug = False
log_prior = log_prior_enigma(q,
total_mass,
PNO,
coeffs,
m_omega_attach,
all_params,
omega_fit_tag,
verbose=debug)
if not np.isfinite(log_prior):
return log_prior
# posterior = likelihood x prior
return log_likelihood_enigma(
mass1,
mass2,
m_omega_attach,
PNO,
f_lower,
inputs.sample_rate,
psd,
dilation_map_match=dilation_map_match) + log_prior
def get_params(file):
"""
Read waveform meta data from hdf5 file
"""
f = h5py.File(file, "r")
# Metadata parameters:
params = {}
params["eta"] = float(f.attrs["eta"])
params["spin1x"] = float(f.attrs["spin1x"])
params["spin1y"] = float(f.attrs["spin1y"])
params["spin1z"] = float(f.attrs["spin1z"])
params["spin2x"] = float(f.attrs["spin2x"])
params["spin2y"] = float(f.attrs["spin2y"])
params["spin2z"] = float(f.attrs["spin2z"])
params["Mmin30Hz"] = float(f.attrs["f_lower_at_1MSUN"]) / 30.0
mass1, mass2 = pnutils.mtotal_eta_to_mass1_mass2(params["Mmin30Hz"], params["eta"])
params["Mchirpmin30Hz"], _ = pnutils.mass1_mass2_to_mchirp_eta(mass1, mass2)
params["q"] = mass1 / mass2
# --- Derived spin configuration
params["a1"] = np.linalg.norm([params["spin1x"], params["spin1y"], params["spin1z"]])
params["a2"] = np.linalg.norm([params["spin2x"], params["spin2y"], params["spin2z"]])
params["a1dotL"], vec = nrbu.a_with_L(params["spin1x"], params["spin1y"], params["spin1z"])
params["a1crossL"] = np.linalg.norm(vec)
params["a2dotL"], vec = nrbu.a_with_L(params["spin2x"], params["spin2y"], params["spin2z"])
params["a2crossL"] = np.linalg.norm(vec)
params["theta_a12"] = nrbu.spin_angle(
params["spin1x"], params["spin1y"], params["spin1z"], params["spin2x"], params["spin2y"], params["spin2z"]
)
params["SeffdotL"], vec = nrbu.effspin_with_L(
params["q"],
params["spin1x"],
params["spin1y"],
params["spin1z"],
params["spin2x"],
params["spin2y"],
params["spin2z"],
)
params["SeffcrossL"] = np.linalg.norm(vec)
params["SdotL"], params["theta_SdotL"] = nrbu.totspin_dot_L(
params["q"],
params["spin1x"],
params["spin1y"],
params["spin1z"],
params["spin2x"],
params["spin2y"],
params["spin2z"],
)
params["wavefile"] = os.path.abspath(file)
return params
