def GravitationalWaveAdaptive(fmin, fmax, m1_min, m2_min, dflim=5):
''' Simple algorithm to create an array of frequencies and deltaF's
based on gravitational wave signal duration.
Written by Michael Purrer.
INPUT
=====
fmin --- starting frequency
fmax --- ending frequency
dflim --- maximum allowed df
m1_min --- smallest component mass of body 1
m2_min --- smallest component mass of body 2'''
import lal
import lalsimulation as LS
df_array = []
f_array = []
f = fmin
while f < fmax:
try:
df = 0.2 / LS.SimIMRSEOBNRv2ROMDoubleSpinHITimeOfFrequency(
f, m1_min * lal.MSUN_SI, m2_min * lal.MSUN_SI, 0, 0)
except Exception, e:
print str(e)
df = dflim # At very high frequencies the above call can fail, but we know that the frequency spacing would be huge there
#print f, df
if abs(df) > dflim: df = dflim
f_array.append(f)
df_array.append(df)
f += df
def ComputeDeltaF(Mc, eta, chi=0.99, f_min=20):
Mtot = Mfun(Mc, eta)
q = qfun(eta)
# print Mtot, q
m1 = m1fun(Mtot, q) * lal.MSUN_SI
m2 = m2fun(Mtot, q) * lal.MSUN_SI
T = LS.SimIMRSEOBNRv2ROMDoubleSpinHITimeOfFrequency(
f_min, m1, m2, chi, chi)
# print 'T = 1/df[Hz]', T
# print 'df [Hz]', 1.0 / T
return round(T)
def get_inspiral_tf(tc, mass1, mass2, spin1, spin2, f_low, n_points=100,
pn_2order=7, approximant='TaylorF2'):
"""Compute the time-frequency evolution of an inspiral signal.
Return a tuple of time and frequency vectors tracking the evolution of an
inspiral signal in the time-frequency plane.
"""
# handle param-dependent approximant specification
class Params:
pass
params = Params()
params.mass1 = mass1
params.mass2 = mass2
params.spin1z = spin1
params.spin2z = spin2
try:
approximant = eval(approximant, {'__builtins__': None},
dict(params=params))
except NameError:
pass
if approximant in ['TaylorF2', 'SPAtmplt']:
from pycbc.waveform.spa_tmplt import findchirp_chirptime
# FIXME spins are not taken into account
f_high = f_SchwarzISCO(mass1 + mass2)
track_f = numpy.logspace(numpy.log10(f_low), numpy.log10(f_high),
n_points)
track_t = numpy.array([findchirp_chirptime(float(mass1), float(mass2),
float(f), pn_2order) for f in track_f])
elif approximant in ['SEOBNRv2', 'SEOBNRv2_ROM_DoubleSpin',
'SEOBNRv2_ROM_DoubleSpin_HI']:
f_high = get_final_freq('SEOBNRv2', mass1, mass2, spin1, spin2)
track_f = numpy.logspace(numpy.log10(f_low), numpy.log10(f_high),
n_points)
# use HI function as it has wider freq range validity
track_t = numpy.array([
lalsimulation.SimIMRSEOBNRv2ROMDoubleSpinHITimeOfFrequency(f,
solar_mass_to_kg(mass1), solar_mass_to_kg(mass2),
float(spin1), float(spin2)) for f in track_f])
elif approximant in ['SEOBNRv4', 'SEOBNRv4_ROM']:
f_high = get_final_freq('SEOBNRv4', mass1, mass2, spin1, spin2)
# use frequency below final freq in case of rounding error
track_f = numpy.logspace(numpy.log10(f_low), numpy.log10(0.999*f_high),
n_points)
track_t = numpy.array([
lalsimulation.SimIMRSEOBNRv4ROMTimeOfFrequency(
f, solar_mass_to_kg(mass1), solar_mass_to_kg(mass2),
float(spin1), float(spin2)) for f in track_f])
else:
raise ValueError('Approximant ' + approximant + ' not supported')
return (tc - track_t, track_f)
