def match(self):
match_result = []
injtau0 = conversions.tau0_from_mass1_mass2(0.1,
0.1,
f_lower=self.f_lower)
for i in range(self.inj_num):
print('i is %s' % i)
hpinj, _ = get_fd_waveform(approximant="TaylorF2e",
mass1=0.1,
mass2=0.1,
eccentricity=self.injecc[i],
long_asc_nodes=self.injection['pol'][i],
inclination=self.injection['inc'][i],
delta_f=self.delta_f,
f_lower=self.f_lower,
f_final=self.f_upper)
# scan the template bank to find the maximum match
index = np.where(np.abs(injtau0 - self.bank_tau0) < 3)
max_match, max_m1, max_m2 = None, None, None
for k in index[0]:
hpbank, __ = get_fd_waveform(approximant="TaylorF2",
mass1=self.bank_m1[k],
mass2=self.bank_m2[k],
phase_order=6,
delta_f=self.delta_f,
f_lower=self.f_lower,
f_final=self.f_upper)
cache_match, _ = match(hpinj,
hpbank,
psd=self.psd,
low_frequency_cutoff=self.f_lower,
high_frequency_cutoff=self.f_upper)
print('ecc=%f,m1=%f,m2=%f,match=%f' %
(self.injecc[i], self.bank_m1[k], self.bank_m2[k],
cache_match))
if max_match == None:
max_match = cache_match
max_m1 = self.bank_m1[k]
max_m2 = self.bank_m2[k]
elif cache_match > max_match:
max_match = cache_match
max_m1 = self.bank_m1[k]
max_m2 = self.bank_m2[k]
match_result.append([
0.1, 0.1, self.injecc[i], self.injection['pol'][i],
self.injection['inc'][i], max_match, max_m1, max_m2
])
np.savetxt(
'result' + str(sys.argv[1]) + '.txt',
match_result,
fmt='%f',
header='injm1 injm2 injecc injpol injinc maxmatch maxm1 maxm2'
)
return match_result
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, _ = pnutils.mass1_mass2_to_mchirp_eta(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 __init__(self,
bankfile,
f_lower=20,
f_upper=1024,
delta_f=0.0001,
**args):
self.seed = int(sys.argv[1])
np.random.seed(self.seed)
self.bank_m1 = bankfile[:, 0]
self.bank_m2 = bankfile[:, 1]
self.f_lower = f_lower
self.f_upper = f_upper
self.delta_f = delta_f
self.bank_tau0 = conversions.tau0_from_mass1_mass2(
self.bank_m1, self.bank_m2, f_lower=self.f_lower)
self.bank_size = len(self.bank_m1)
self.inj_num = int(args['inj_num'])
self.injection = distributions.uniform.Uniform(
pol=(0, 2 * np.pi),
inc=(-np.pi / 2, np.pi / 2)).rvs(size=self.inj_num)
self.eccrand = np.random.uniform(0, cumsum[-1], self.inj_num)
self.injecc = eccfile[np.digitize(self.eccrand, cumsum), 0]
self.psd = aLIGOZeroDetHighPower(
int(self.f_upper / self.delta_f) + 1, self.delta_f, self.f_lower)
def mass1_mass2_to_tau0_tau3(mass1, mass2, f_lower):
tau0 = conversions.tau0_from_mass1_mass2(mass1, mass2, f_lower)
tau3 = conversions.tau3_from_mass1_mass2(mass1, mass2, f_lower)
return tau0,tau3
def apply(self,
strain,
detector_name,
f_lower=None,
distance_scale=1,
simulation_ids=None,
inj_filter_rejector=None):
"""Add injections (as seen by a particular detector) to a time series.
Parameters
----------
strain : TimeSeries
Time series to inject signals into, of type float32 or float64.
detector_name : string
Name of the detector used for projecting injections.
f_lower : {None, float}, optional
Low-frequency cutoff for injected signals. If None, use value
provided by each injection.
distance_scale: {1, float}, optional
Factor to scale the distance of an injection with. The default is
no scaling.
simulation_ids: iterable, optional
If given, only inject signals with the given simulation IDs.
inj_filter_rejector: InjFilterRejector instance; optional, default=None
If given send each injected waveform to the InjFilterRejector
instance so that it can store a reduced representation of that
injection if necessary.
Returns
-------
None
Raises
------
TypeError
For invalid types of `strain`.
"""
if strain.dtype not in (float32, float64):
raise TypeError("Strain dtype must be float32 or float64, not " \
+ str(strain.dtype))
lalstrain = strain.lal()
earth_travel_time = lal.REARTH_SI / lal.C_SI
t0 = float(strain.start_time) - earth_travel_time
t1 = float(strain.end_time) + earth_travel_time
# pick lalsimulation injection function
add_injection = injection_func_map[strain.dtype]
injections = self.table
if simulation_ids:
injections = injections[list(simulation_ids)]
for ii, inj in enumerate(injections):
f_l = inj.f_lower if f_lower is None else f_lower
# roughly estimate if the injection may overlap with the segment
# Add 2s to end_time to account for ringdown and light-travel delay
end_time = inj.tc + 2
inj_length = tau0_from_mass1_mass2(inj.mass1, inj.mass2, f_l)
# Start time is taken as twice approx waveform length with a 1s
# safety buffer
start_time = inj.tc - 2 * (inj_length + 1)
if end_time < t0 or start_time > t1:
continue
signal = self.make_strain_from_inj_object(
inj,
strain.delta_t,
detector_name,
f_lower=f_l,
distance_scale=distance_scale)
if float(signal.start_time) > t1:
continue
signal = signal.astype(strain.dtype)
signal_lal = signal.lal()
add_injection(lalstrain, signal_lal, None)
if inj_filter_rejector is not None:
inj_filter_rejector.generate_short_inj_from_inj(signal, ii)
strain.data[:] = lalstrain.data.data[:]
injected = copy.copy(self)
injected.table = injections
if inj_filter_rejector is not None:
inj_filter_rejector.injection_params = injected
return injected
def mass1_mass2_to_tau0_tau3(mass1, mass2, f_lower):
tau0 = conversions.tau0_from_mass1_mass2(mass1, mass2, f_lower)
tau3 = conversions.tau3_from_mass1_mass2(mass1, mass2, f_lower)
return tau0,tau3
