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)