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