def inverse_jacobian(self, maps):
"""Returns the Jacobian for the transforming mass1 and mass2 to
mchirp and q.
"""
m1 = conversions.primary_mass(maps['mass1'], maps['mass2'])
m2 = conversions.secondary_mass(maps['mass1'], maps['mass2'])
return conversions.mchirp_from_mass1_mass2(m1, m2) / m2**2.
def inverse_jacobian(self, maps):
"""Returns the Jacobian for the transforming mass1 and mass2 to
mchirp and q.
"""
m1 = conversions.primary_mass(maps['mass1'], maps['mass2'])
m2 = conversions.secondary_mass(maps['mass1'], maps['mass2'])
return conversions.mchirp_from_mass1_mass2(m1, m2)/m2**2.
def inverse_transform(self, maps):
"""This function transforms from component masses to chirp mass and
mass ratio.
Parameters
----------
maps : a mapping object
Examples
--------
Convert a dict of numpy.array:
>>> import numpy
>>> from pycbc import transforms
>>> t = transforms.MchirpQToMass1Mass2()
>>> t.inverse_transform({'mass1': numpy.array([16.4]), 'mass2': numpy.array([8.2])})
{'mass1': array([ 16.4]), 'mass2': array([ 8.2]),
'mchirp': array([ 9.97717521]), 'q': 2.0}
Returns
-------
out : dict
A dict with key as parameter name and value as numpy.array or float
of transformed values.
"""
out = {}
out[parameters.mchirp] = \
conversions.mchirp_from_mass1_mass2(maps[parameters.mass1],
maps[parameters.mass2])
m_p = conversions.primary_mass(maps[parameters.mass1],
maps[parameters.mass2])
m_s = conversions.secondary_mass(maps[parameters.mass1],
maps[parameters.mass2])
out[parameters.q] = m_p / m_s
return self.format_output(maps, out)
def inverse_transform(self, maps):
"""This function transforms from component masses to chirp mass and
mass ratio.
Parameters
----------
maps : a mapping object
Examples
--------
Convert a dict of numpy.array:
>>> import numpy
>>> from pycbc import transforms
>>> t = transforms.MchirpQToMass1Mass2()
>>> t.inverse_transform({'mass1': numpy.array([16.4]), 'mass2': numpy.array([8.2])})
{'mass1': array([ 16.4]), 'mass2': array([ 8.2]),
'mchirp': array([ 9.97717521]), 'q': 2.0}
Returns
-------
out : dict
A dict with key as parameter name and value as numpy.array or float
of transformed values.
"""
out = {}
out[parameters.mchirp] = \
conversions.mchirp_from_mass1_mass2(maps[parameters.mass1],
maps[parameters.mass2])
m_p = conversions.primary_mass(maps[parameters.mass1],
maps[parameters.mass2])
m_s = conversions.secondary_mass(maps[parameters.mass1],
maps[parameters.mass2])
out[parameters.q] = m_p / m_s
return self.format_output(maps, out)
def process_full_data(fname, rhomin, mass1, mass2, lo_mchirp, hi_mchirp):
"""Read the zero-lag and time-lag triggers identified by templates in
a specified range of chirp mass.
Parameters
----------
hdfile:
File that stores all the triggers
rhomin: float
Minimum value of SNR threhold (will need including ifar)
mass1: array
First mass of the waveform in the template bank
mass2: array
Second mass of the waveform in the template bank
lo_mchirp: float
Minimum chirp mass for the template
hi_mchirp: float
Maximum chirp mass for the template
Returns
-------
dictionary
containing foreground triggers and background information
"""
with h5py.File(fname, 'r') as bulk:
id_bkg = bulk['background_exc/template_id'][:]
id_fg = bulk['foreground/template_id'][:]
mchirp_bkg = mchirp_from_mass1_mass2(mass1[id_bkg], mass2[id_bkg])
bound = np.sign((mchirp_bkg - lo_mchirp) * (hi_mchirp - mchirp_bkg))
idx_bkg = np.where(bound == 1)
mchirp_fg = mchirp_from_mass1_mass2(mass1[id_fg], mass2[id_fg])
bound = np.sign((mchirp_fg - lo_mchirp) * (hi_mchirp - mchirp_fg))
idx_fg = np.where(bound == 1)
zerolagstat = bulk['foreground/stat'][:][idx_fg]
cstat_back_exc = bulk['background_exc/stat'][:][idx_bkg]
dec_factors = bulk['background_exc/decimation_factor'][:][idx_bkg]
return {
'zerolagstat': zerolagstat[zerolagstat > rhomin],
'dec_factors': dec_factors[cstat_back_exc > rhomin],
'cstat_back_exc': cstat_back_exc[cstat_back_exc > rhomin]
}
def process_full_data(fname, rhomin, mass1, mass2, lo_mchirp, hi_mchirp):
"""Read the zero-lag and time-lag triggers identified by templates in
a specified range of chirp mass.
Parameters
----------
hdfile:
File that stores all the triggers
rhomin: float
Minimum value of SNR threhold (will need including ifar)
mass1: array
First mass of the waveform in the template bank
mass2: array
Second mass of the waveform in the template bank
lo_mchirp: float
Minimum chirp mass for the template
hi_mchirp: float
Maximum chirp mass for the template
Returns
-------
dictionary
containing foreground triggers and background information
"""
with h5py.File(fname, 'r') as bulk:
id_bkg = bulk['background_exc/template_id'][:]
id_fg = bulk['foreground/template_id'][:]
mchirp_bkg = mchirp_from_mass1_mass2(mass1[id_bkg], mass2[id_bkg])
bound = np.sign((mchirp_bkg - lo_mchirp) * (hi_mchirp - mchirp_bkg))
idx_bkg = np.where(bound == 1)
mchirp_fg = mchirp_from_mass1_mass2(mass1[id_fg], mass2[id_fg])
bound = np.sign((mchirp_fg - lo_mchirp) * (hi_mchirp - mchirp_fg))
idx_fg = np.where(bound == 1)
zerolagstat = bulk['foreground/stat'][:][idx_fg]
cstat_back_exc = bulk['background_exc/stat'][:][idx_bkg]
dec_factors = bulk['background_exc/decimation_factor'][:][idx_bkg]
return {'zerolagstat': zerolagstat[zerolagstat > rhomin],
'dec_factors': dec_factors[cstat_back_exc > rhomin],
'cstat_back_exc': cstat_back_exc[cstat_back_exc > rhomin]}
def setUp(self, *args):
self.numtests = 1000
self.precision = 1e-8
self.f_lower = 10.
# create some component masses to work with
self.m1 = numpy.random.uniform(1., 100., size=self.numtests)
self.m2 = numpy.random.uniform(1., 100., size=self.numtests)
# create some spins to work with
spin_angledist = distributions.UniformSolidAngle()
rvals = spin_angledist.rvs(size=self.numtests)
self.spin1_polar = rvals['theta']
self.spin1_az = rvals['phi']
self.spin1_amp = numpy.random.uniform(0., 1., size=self.numtests)
rvals = spin_angledist.rvs(size=self.numtests)
self.spin2_polar = rvals['theta']
self.spin2_az = rvals['phi']
self.spin2_amp = numpy.random.uniform(0., 1., size=self.numtests)
# calculate derived parameters from each
self.mp = conversions.primary_mass(self.m1, self.m2)
self.ms = conversions.secondary_mass(self.m1, self.m2)
self.mtotal = conversions.mtotal_from_mass1_mass2(self.m1, self.m2)
self.q = conversions.q_from_mass1_mass2(self.m1, self.m2)
self.invq = conversions.invq_from_mass1_mass2(self.m1, self.m2)
self.mchirp = conversions.mchirp_from_mass1_mass2(self.m1, self.m2)
self.eta = conversions.eta_from_mass1_mass2(self.m1, self.m2)
self.tau0 = conversions.tau0_from_mtotal_eta(self.mtotal, self.eta,
self.f_lower)
self.tau3 = conversions.tau3_from_mtotal_eta(self.mtotal, self.eta,
self.f_lower)
self.spin1x, self.spin1y, self.spin1z = \
coordinates.spherical_to_cartesian(self.spin1_amp, self.spin1_az,
self.spin1_polar)
self.spin2x, self.spin2y, self.spin2z = \
coordinates.spherical_to_cartesian(self.spin2_amp, self.spin2_az,
self.spin2_polar)
self.effective_spin = conversions.chi_eff(self.m1, self.m2,
self.spin1z, self.spin2z)
self.chi_p = conversions.chi_p(self.m1, self.m2, self.spin1x,
self.spin1y, self.spin2x, self.spin2y)
self.primary_spinx = conversions.primary_spin(self.m1, self.m2,
self.spin1x, self.spin2x)
self.primary_spiny = conversions.primary_spin(self.m1, self.m2,
self.spin1y, self.spin2y)
self.primary_spinz = conversions.primary_spin(self.m1, self.m2,
self.spin1z, self.spin2z)
self.secondary_spinx = conversions.secondary_spin(self.m1, self.m2,
self.spin1x, self.spin2x)
self.secondary_spiny = conversions.secondary_spin(self.m1, self.m2,
self.spin1y, self.spin2y)
self.secondary_spinz = conversions.secondary_spin(self.m1, self.m2,
self.spin1z, self.spin2z)
def setUp(self, *args):
self.numtests = 1000
self.precision = 1e-8
self.f_lower = 10.
# create some component masses to work with
self.m1 = numpy.random.uniform(1., 100., size=self.numtests)
self.m2 = numpy.random.uniform(1., 100., size=self.numtests)
# create some spins to work with
spin_angledist = distributions.UniformSolidAngle()
rvals = spin_angledist.rvs(size=self.numtests)
self.spin1_polar = rvals['theta']
self.spin1_az = rvals['phi']
self.spin1_amp = numpy.random.uniform(0., 1., size=self.numtests)
rvals = spin_angledist.rvs(size=self.numtests)
self.spin2_polar = rvals['theta']
self.spin2_az = rvals['phi']
self.spin2_amp = numpy.random.uniform(0., 1., size=self.numtests)
# calculate derived parameters from each
self.mp = conversions.primary_mass(self.m1, self.m2)
self.ms = conversions.secondary_mass(self.m1, self.m2)
self.mtotal = conversions.mtotal_from_mass1_mass2(self.m1, self.m2)
self.q = conversions.q_from_mass1_mass2(self.m1, self.m2)
self.invq = conversions.invq_from_mass1_mass2(self.m1, self.m2)
self.mchirp = conversions.mchirp_from_mass1_mass2(self.m1, self.m2)
self.eta = conversions.eta_from_mass1_mass2(self.m1, self.m2)
self.tau0 = conversions.tau0_from_mtotal_eta(self.mtotal, self.eta,
self.f_lower)
self.tau3 = conversions.tau3_from_mtotal_eta(self.mtotal, self.eta,
self.f_lower)
self.spin1x, self.spin1y, self.spin1z = \
coordinates.spherical_to_cartesian(self.spin1_amp, self.spin1_az,
self.spin1_polar)
self.spin2x, self.spin2y, self.spin2z = \
coordinates.spherical_to_cartesian(self.spin2_amp, self.spin2_az,
self.spin2_polar)
self.effective_spin = conversions.chi_eff(self.m1, self.m2,
self.spin1z, self.spin2z)
self.primary_spinx = conversions.primary_spin(self.m1, self.m2,
self.spin1x, self.spin2x)
self.primary_spiny = conversions.primary_spin(self.m1, self.m2,
self.spin1y, self.spin2y)
self.primary_spinz = conversions.primary_spin(self.m1, self.m2,
self.spin1z, self.spin2z)
self.secondary_spinx = conversions.secondary_spin(self.m1, self.m2,
self.spin1x, self.spin2x)
self.secondary_spiny = conversions.secondary_spin(self.m1, self.m2,
self.spin1y, self.spin2y)
self.secondary_spinz = conversions.secondary_spin(self.m1, self.m2,
self.spin1z, self.spin2z)
def get_found_param(injfile, bankfile, trigfile, param, ifo):
"""
Translates some popular trigger parameters into functions that calculate
them from an hdf found injection file
Parameters
----------
injfile: hdf5 File object
Injection file of format known to ANitz (DOCUMENTME)
bankfile: hdf5 File object or None
Template bank file
trigfile: hdf5 File object or None
Single-detector trigger file
param: string
Parameter to be calculated for the recovered triggers
ifo: string or None
Standard ifo name, ex. 'L1'
Returns
-------
[return value]: NumPy array of floats
The calculated parameter values
"""
foundtmp = injfile["found_after_vetoes/template_id"][:]
if trigfile is not None:
# get the name of the ifo in the injection file, eg "detector_1"
# and the integer from that name
ifolabel = [name for name, val in injfile.attrs.items() if \
"detector" in name and val == ifo][0]
foundtrg = injfile["found_after_vetoes/trigger_id" + ifolabel[-1]]
if bankfile is not None and param in bankfile.keys():
return bankfile[param][:][foundtmp]
elif trigfile is not None and param in trigfile[ifo].keys():
return trigfile[ifo][param][:][foundtrg]
else:
b = bankfile
found_param_dict = {
"mtotal" : (b['mass1'][:] + b['mass2'][:])[foundtmp],
"mchirp" : conversions.mchirp_from_mass1_mass2(b['mass1'][:],
b['mass2'][:])[foundtmp],
"eta" : conversions.eta_from_mass1_mass2(b['mass1'][:],
b['mass2'][:])[foundtmp],
"effective_spin" : conversions.chi_eff(b['mass1'][:],
b['mass2'][:],
b['spin1z'][:],
b['spin2z'][:])[foundtmp]
}
return found_param_dict[param]
def keep_loudest_in_interval(self,
window,
num_keep,
statname="newsnr",
log_chirp_width=None):
if len(self.events) == 0:
return
from pycbc.events import stat
e_copy = self.events.copy()
# Here self.events['snr'] is the complex SNR
e_copy['snr'] = abs(e_copy['snr'])
# Messy step because pycbc inspiral's internal 'chisq_dof' is 2p-2
# but stat.py / ranking.py functions use 'chisq_dof' = p
e_copy['chisq_dof'] = e_copy['chisq_dof'] / 2 + 1
# Initialize statclass with an empty file list
stat_instance = stat.sngl_statistic_dict[statname]([])
statv = stat_instance.single(e_copy)
# Convert trigger time to integer bin number
# NB time_index and window are in units of samples
wtime = (e_copy['time_index'] / window).astype(numpy.int32)
bins = numpy.unique(wtime)
if log_chirp_width:
from pycbc.conversions import mchirp_from_mass1_mass2
m1 = numpy.array([p['tmplt'].mass1 for p in self.template_params])
m2 = numpy.array([p['tmplt'].mass2 for p in self.template_params])
mc = mchirp_from_mass1_mass2(m1, m2)[e_copy['template_id']]
# convert chirp mass to integer bin number
imc = (numpy.log(mc) / log_chirp_width).astype(numpy.int32)
cbins = numpy.unique(imc)
keep = []
for b in bins:
if log_chirp_width:
for b2 in cbins:
bloc = numpy.where((wtime == b) & (imc == b2))[0]
bloudest = statv[bloc].argsort()[-num_keep:]
keep.append(bloc[bloudest])
else:
bloc = numpy.where((wtime == b))[0]
bloudest = statv[bloc].argsort()[-num_keep:]
keep.append(bloc[bloudest])
keep = numpy.concatenate(keep)
self.events = self.events[keep]
def mchirp_sampler_flat(**kwargs):
''' Draw chirp mass samples for flat in mass model
Parameters
----------
**kwargs: string
Keyword arguments as model parameters and number of samples
Returns
-------
mchirp-astro: array
The chirp mass samples for the population
'''
m1, m2 = draw_flat_samples(**kwargs)
mchirp_astro = mchirp_from_mass1_mass2(m1, m2)
return mchirp_astro
def mchirp_sampler_flat(**kwargs):
''' Draw chirp mass samples for flat in mass model
Parameters
----------
**kwargs: string
Keyword arguments as model parameters and number of samples
Returns
-------
mchirp-astro: array
The chirp mass samples for the population
'''
m1, m2 = draw_flat_samples(**kwargs)
mchirp_astro = mchirp_from_mass1_mass2(m1, m2)
return mchirp_astro
def get_param(par, args, m1, m2, s1z, s2z):
"""
Helper function
Parameters
----------
par : string
Name of parameter to calculate
args : Namespace object returned from ArgumentParser instance
Calling code command line options, used for f_lower value
m1 : float or array of floats
First binary component mass (etc.)
Returns
-------
parvals : float or array of floats
Calculated parameter values
"""
if par == 'mchirp':
parvals = conversions.mchirp_from_mass1_mass2(m1, m2)
elif par == 'mtotal':
parvals = m1 + m2
elif par == 'eta':
parvals = conversions.eta_from_mass1_mass2(m1, m2)
elif par in ['chi_eff', 'effective_spin']:
parvals = conversions.chi_eff(m1, m2, s1z, s2z)
elif par == 'template_duration':
# default to SEOBNRv4 duration function
if not hasattr(args, 'approximant') or args.approximant is None:
args.approximant = "SEOBNRv4"
parvals = pnutils.get_imr_duration(m1, m2, s1z, s2z, args.f_lower,
args.approximant)
if args.min_duration:
parvals += args.min_duration
elif par == 'tau0':
parvals = conversions.tau0_from_mass1_mass2(m1, m2, args.f_lower)
elif par == 'tau3':
parvals = conversions.tau3_from_mass1_mass2(m1, m2, args.f_lower)
elif par in pnutils.named_frequency_cutoffs.keys():
parvals = pnutils.frequency_cutoff_from_name(par, m1, m2, s1z, s2z)
else:
# try asking for a LALSimulation frequency function
parvals = pnutils.get_freq(par, m1, m2, s1z, s2z)
return parvals
def get_param(par, args, m1, m2, s1z, s2z):
"""
Helper function
Parameters
----------
par : string
Name of parameter to calculate
args : Namespace object returned from ArgumentParser instance
Calling code command line options, used for f_lower value
m1 : float or array of floats
First binary component mass (etc.)
Returns
-------
parvals : float or array of floats
Calculated parameter values
"""
if par == 'mchirp':
parvals = conversions.mchirp_from_mass1_mass2(m1, m2)
elif par == 'mtotal':
parvals = m1 + m2
elif par == 'eta':
parvals = conversions.eta_from_mass1_mass2(m1, m2)
elif par in ['chi_eff', 'effective_spin']:
parvals = conversions.chi_eff(m1, m2, s1z, s2z)
elif par == 'template_duration':
# default to SEOBNRv4 duration function
parvals = pnutils.get_imr_duration(m1, m2, s1z, s2z, args.f_lower,
args.approximant or "SEOBNRv4")
if args.min_duration:
parvals += args.min_duration
elif par == 'tau0':
parvals = conversions.tau0_from_mass1_mass2(m1, m2, args.f_lower)
elif par == 'tau3':
parvals = conversions.tau3_from_mass1_mass2(m1, m2, args.f_lower)
elif par in pnutils.named_frequency_cutoffs.keys():
parvals = pnutils.frequency_cutoff_from_name(par, m1, m2, s1z, s2z)
else:
# try asking for a LALSimulation frequency function
parvals = pnutils.get_freq(par, m1, m2, s1z, s2z)
return parvals
def get_inj_param(injfile, param, ifo):
"""
Translates some popular injection parameters into functions that calculate
them from an hdf found injection file
Parameters
----------
injfile: hdf5 File object
Injection file of format known to ANitz (DOCUMENTME)
param: string
Parameter to be calculated for the injected signals
ifo: string
Standard detector name, ex. 'L1'
Returns
-------
[return value]: NumPy array of floats
The calculated parameter values
"""
det = pycbc.detector.Detector(ifo)
time_delay = numpy.vectorize(#lambda dec, ra, t :
det.time_delay_from_earth_center)#(dec, ra, t))
inj = injfile["injections"]
if param in inj.keys():
return inj["injections/"+param]
inj_param_dict = {
"mtotal" : inj['mass1'][:] + inj['mass2'][:],
"mchirp" : conversions.mchirp_from_mass1_mass2(inj['mass1'][:],
inj['mass2'][:]),
"eta" : conversions.eta_from_mass1_mass2(inj['mass1'][:],
inj['mass2'][:]),
"effective_spin" : conversions.chi_eff(inj['mass1'][:],
inj['mass2'][:],
inj['spin1z'][:],
inj['spin2z'][:]),
"end_time_"+ifo[0].lower() :
inj['end_time'][:] + time_delay(inj['longitude'][:],
inj['latitude'][:],
inj['end_time'][:]),
}
return inj_param_dict[param]
def transform_masses(mass1, mass2, mchirp_mod, eta_mod):
"""Modifies masses given a difference in mchirp and eta.
Parameters
----------
mass1 : float
Mass of the larger object (already modified).
mass2 : float
Mass of the smaller object (already modified).
mchirp_mod : tuple of (float, str) or None
Tuple giving the modification value for ``mchirp``, and a string
indicating whether the given modification is a fractional difference
(``'fdiff'``), an absolute difference (``'absdiff'``), or a replacement
(``'replace'``). If ``None``, the chirp mass will not be modified.
eta_mod : tuple of (float, str)
Same as ``mchirp_mod``, but for ``eta``.
Returns
-------
mass1 : float
Modified mass1.
mass2 : float
Modified mass2.
"""
mchirp = conversions.mchirp_from_mass1_mass2(mass1, mass2)
eta = conversions.eta_from_mass1_mass2(mass1, mass2)
if mchirp_mod is not None:
diff, modtype = mchirp_mod
mchirp = apply_mod(mchirp, diff, modtype)
if eta_mod is not None:
diff, modtype = eta_mod
eta = apply_mod(eta, diff, modtype)
# make sure values are physical
if (eta < 0 or eta > 0.25) or mchirp < 0:
raise NoWaveformError("unphysical masses")
m1 = conversions.mass1_from_mchirp_eta(mchirp, eta)
m2 = conversions.mass2_from_mchirp_eta(mchirp, eta)
return m1, m2
def keep_loudest_in_interval(self, window, num_keep, log_chirp_width=None):
if len(self.events) == 0:
return
e = self.events
# FIXME allow statistics that are not newsnr
stat = ranking.newsnr(abs(e['snr']), e['chisq'] / e['chisq_dof'])
time = e['time_index']
# convert time to integer bin number
wtime = (time / window).astype(numpy.int32)
bins = numpy.unique(wtime)
if log_chirp_width:
from pycbc.conversions import mchirp_from_mass1_mass2
m1 = numpy.array([p['tmplt'].mass1 for p in self.template_params])
m2 = numpy.array([p['tmplt'].mass2 for p in self.template_params])
mc = mchirp_from_mass1_mass2(m1, m2)[e['template_id']]
# convert chirp mass to an integer which indicates its cluster bin
imc = (numpy.log(mc) / log_chirp_width).astype(numpy.int32)
cbins = numpy.unique(imc)
keep = []
for b in bins:
if log_chirp_width:
for b2 in cbins:
bloc = numpy.where((wtime == b) & (imc == b2))[0]
bloudest = stat[bloc].argsort()[-num_keep:]
keep.append(bloc[bloudest])
else:
bloc = numpy.where((wtime == b))[0]
bloudest = stat[bloc].argsort()[-num_keep:]
keep.append(bloc[bloudest])
keep = numpy.concatenate(keep)
self.events = e[keep]
def mchirp(self):
return conversions.mchirp_from_mass1_mass2(self.mass1, self.mass2)
fp = InferenceFile("posteriors/GW150914/gw150914_posteriors_thinned.hdf", "r")
mass1_samples = fp['samples/mass1'][:]
print mass1_samples
# Using the PyCBC software, one can map the posteriors for the `variable_args` to posteriors of other parameters. PyCBC has several functions that can be used to do the general transforms between parameters. You can look in `pycbc.conversions`, `pycbc.coordinates`, `pycbc.cosmology` for the possible transforms that you can do with the available `variable_args`. For example, to obtain the the chirp mass of the binary `mchirp` from the component masses `(mass1, mass2)` one would do :
# In[4]:
from pycbc import conversions
fp = InferenceFile("posteriors/GW150914/gw150914_posteriors_thinned.hdf", 'r')
mass1 = fp['samples/mass1'][:]
mass2 = fp['samples/mass2'][:]
fp.close()
mchirp = conversions.mchirp_from_mass1_mass2(mass1, mass2)
print mchirp
# PyCBC has some common transforms pre-defined in the code, which can be used to derive some of the standard parameters from the `variable_args` parameters in the data file. For example, `( mass1, mass2 )` present in `variable_args` can be used to obtain derived parameters such as `mchirp` and `q`. The parameters whose posteriors are plotted below include some of such derived parameters.
# Below are examples that will plot posteriors from the PyCBC Inference analysis of GW150914 presented in Figures 4, 5 and 6 in the paper.
#
# For generating the the $m_1^{\mathrm{src}} - m_2^{\mathrm{src}}$ posteriors plot, we have utilized plotting functions from the module https://github.com/gwastro/pycbc/blob/v1.12.3/pycbc/results/scatter_histograms.py in PyCBC.
# To generate the $q - \chi_{\mathrm{eff}}$ and $d_L - \iota$ posteriors plots, we use the built-in plotting executable `pycbc_inference_plot_posterior` provided by PyCBC Inference that handles formatting and any necessary parameter conversions. Some formatting differences may be present, but if you're running a development version of PyCBC then you can adjust these as desired in the plotting code.
# ### Some plotting functions used in generating $m_1 - m_2$ posteriors
# In[3]:
import argparse
import logging
def filter_tmplt_mchirp(bankf, lo_mchirp, hi_mchirp):
with h5py.File(bankf) as bank:
mchirp = conv.mchirp_from_mass1_mass2(bank['mass1'][:],
bank['mass2'][:])
# Boolean over template id
return filter_bin_lo_hi(mchirp, lo_mchirp, hi_mchirp)
def mchirp(self):
return conversions.mchirp_from_mass1_mass2(self.mass1, self.mass2)
def single(self, trigs):
from pycbc.conversions import mchirp_from_mass1_mass2
self.mchirp = mchirp_from_mass1_mass2(trigs.param['mass1'],
trigs.param['mass2'])
return ExpFitSGFgBgRateNewStatistic.single(self, trigs)
def mass1_mass2_to_mchirp_eta(mass1, mass2):
m_chirp = conversions.mchirp_from_mass1_mass2(mass1, mass2)
eta = conversions.eta_from_mass1_mass2(mass1, mass2)
return m_chirp,eta
def mass1_mass2_to_mchirp_eta(mass1, mass2):
m_chirp = conversions.mchirp_from_mass1_mass2(mass1, mass2)
eta = conversions.eta_from_mass1_mass2(mass1, mass2)
return m_chirp,eta
