def phase(self, frequency_array, phi_c=0, orbital_speed=None):
if orbital_speed is None:
orbital_speed = self.orbital_speed(frequency_array=frequency_array)
phase_coefficients = ls.SimInspiralTaylorF2AlignedPhasing(
self.mass_1, self.mass_2, self.chi_1, self.chi_2, self.param_dict)
phasing = xp.zeros_like(orbital_speed)
cumulative_power_frequency = orbital_speed**-5
for ii in range(len(phase_coefficients.v)):
phasing += phase_coefficients.v[ii] * cumulative_power_frequency
phasing += (phase_coefficients.vlogv[ii] *
cumulative_power_frequency * xp.log(orbital_speed))
cumulative_power_frequency *= orbital_speed
phasing -= 2 * phi_c + np.pi / 4
return phasing
def phase(self, frequency_array, phi_c=0):
orbital_speed = (np.pi * self.total_mass * SOLAR_RADIUS_IN_S *
frequency_array)**(1 / 3)
phase_coefficients = ls.SimInspiralTaylorF2AlignedPhasing(
self.mass_1, self.mass_2, self.chi_1, self.chi_2, CreateDict())
phasing = xp.zeros_like(orbital_speed)
cumulative_power_frequency = orbital_speed**-5
for ii in range(len(phase_coefficients.v)):
phasing += phase_coefficients.v[ii] * cumulative_power_frequency
phasing += (phase_coefficients.vlogv[ii] *
cumulative_power_frequency * xp.log(orbital_speed))
cumulative_power_frequency *= orbital_speed
phasing -= 2 * phi_c + np.pi / 4
phasing = phasing % (2 * np.pi)
return phasing
def spa_tmplt(**kwds):
""" Generate a minimal TaylorF2 approximant with optimations for the sin/cos
"""
# Pull out the input arguments
f_lower = kwds['f_lower']
delta_f = kwds['delta_f']
distance = kwds['distance']
mass1 = kwds['mass1']
mass2 = kwds['mass2']
s1z = kwds['spin1z']
s2z = kwds['spin2z']
phase_order = int(kwds['phase_order'])
#amplitude_order = int(kwds['amplitude_order'])
spin_order = int(kwds['spin_order'])
if 'out' in kwds:
out = kwds['out']
else:
out = None
amp_factor = spa_amplitude_factor(mass1=mass1, mass2=mass2) / distance
lal_pars = lal.CreateDict()
if phase_order != -1:
lalsimulation.SimInspiralWaveformParamsInsertPNPhaseOrder(
lal_pars, phase_order)
if spin_order != -1:
lalsimulation.SimInspiralWaveformParamsInsertPNSpinOrder(
lal_pars, spin_order)
#Calculate the PN terms
phasing = lalsimulation.SimInspiralTaylorF2AlignedPhasing(
float(mass1), float(mass2), float(s1z), float(s2z), lal_pars)
pfaN = phasing.v[0]
pfa2 = phasing.v[2] / pfaN
pfa3 = phasing.v[3] / pfaN
pfa4 = phasing.v[4] / pfaN
pfa5 = phasing.v[5] / pfaN
pfa6 = (phasing.v[6] - phasing.vlogv[6] * log(4)) / pfaN
pfa7 = phasing.v[7] / pfaN
pfl5 = phasing.vlogv[5] / pfaN
pfl6 = phasing.vlogv[6] / pfaN
piM = lal.PI * (mass1 + mass2) * lal.MTSUN_SI
kmin = int(f_lower / float(delta_f))
vISCO = 1. / sqrt(6.)
fISCO = vISCO * vISCO * vISCO / piM
kmax = int(fISCO / delta_f)
f_max = ceilpow2(fISCO)
n = int(f_max / delta_f) + 1
if not out:
htilde = FrequencySeries(zeros(n, dtype=numpy.complex64),
delta_f=delta_f,
copy=False)
else:
if type(out) is not Array:
raise TypeError("Output must be an instance of Array")
if len(out) < kmax:
kmax = len(out)
if out.dtype != complex64:
raise TypeError("Output array is the wrong dtype")
htilde = FrequencySeries(out, delta_f=delta_f, copy=False)
spa_tmplt_engine(htilde[kmin:kmax], kmin, phase_order, delta_f, piM, pfaN,
pfa2, pfa3, pfa4, pfa5, pfl5, pfa6, pfl6, pfa7,
amp_factor)
return htilde
print str(ph.pn.keys()[i]) + " = " + str(ph.pn.values()[i])
print ""
print "Now comparing to LAL"
print "Note, they will differ in the v[6] (3PN) term"
print "because in PhenomD we do not use the 3PN spin-spin term"
try:
import lal
except:
raise ValueError('failed to import lal')
try:
import lalsimulation as lalsim
except:
raise ValueError('failed to import lalsimulation')
lalpn = lalsim.SimInspiralTaylorF2AlignedPhasing(10, 50, 0.3, 0.2, 1, 1, 7)
# print lalpn.v
print "\n\n\n"
print "lal v"
for i in range(len(lalpn.v)):
print str(i) + " = " + str(lalpn.v[i])
print "\n\n\n"
print "lal vlogv"
for i in range(len(lalpn.vlogv)):
print str(i) + " = " + str(lalpn.vlogv[i])
kend = len(psd) - 1
return sqrt(norm1[kend] * norm2) / snr
@schemed("pycbc.waveform.spa_tmplt_")
def spa_tmplt_engine(htilde, kmin, phase_order, delta_f, piM, pfaN, pfa2, pfa3,
pfa4, pfa5, pfl5, pfa6, pfl6, pfa7, amp_factor):
""" Calculate the spa tmplt phase
"""
# FIXME: This a workaround untill all the bundles are upgraded to a new
# version of lalsuite
try:
lalsimulation.SimInspiralTaylorF2AlignedPhasing(1, 1, 0, 0, 1, 1, -1, None)
NEW_F2_SYNTAX = True
except TypeError:
NEW_F2_SYNTAX = False
def spa_tmplt(**kwds):
""" Generate a minimal TaylorF2 approximant with optimations for the sin/cos
"""
# Pull out the input arguments
f_lower = kwds['f_lower']
delta_f = kwds['delta_f']
distance = kwds['distance']
mass1 = kwds['mass1']
mass2 = kwds['mass2']
s1z = kwds['spin1z']
def get_chirp_params_new(mass1, mass2, spin1z, spin2z, f0, order):
"""
Take a set of masses and spins and convert to the various lambda
coordinates that describe the orbital phase. Accepted PN orders are:
{}
Parameters
----------
mass1 : float or array
Mass1 of input(s).
mass2 : float or array
Mass2 of input(s).
spin1z : float or array
Parallel spin component(s) of body 1.
spin2z : float or array
Parallel spin component(s) of body 2.
f0 : float
This is an arbitrary scaling factor introduced to avoid the potential
for numerical overflow when calculating this. Generally the default
value (70) is safe here. **IMPORTANT, if you want to calculate the
ethinca metric components later this MUST be set equal to f_low.**
This value must also be used consistently (ie. don't change its value
when calling different functions!).
order : string
The Post-Newtonian order that is used to translate from masses and
spins to the lambda_i coordinate system. Valid orders given above.
Returns
--------
lambdas : list of floats or numpy.arrays
The lambda coordinates for the input system(s)
"""
# Determine whether array or single value input
sngl_inp = False
try:
num_points = len(mass1)
except TypeError:
sngl_inp = True
# If you care about speed, you aren't calling this function one entry
# at a time.
mass1 = numpy.array([mass1])
mass2 = numpy.array([mass2])
spin1z = numpy.array([spin1z])
spin2z = numpy.array([spin2z])
num_points = 1
lal_pars = CreateDict()
phasing_vs = numpy.zeros([num_points, 13])
phasing_vlogvs = numpy.zeros([num_points, 13])
phasing_vlogvsqs = numpy.zeros([num_points, 13])
for i in xrange(num_points):
phasing = lalsimulation.SimInspiralTaylorF2AlignedPhasing(
mass1[i], mass2[i], spin1z[i], spin2z[i], lal_pars)
phasing_vs[i] = phasing.v
phasing_vlogvs[i] = phasing.vlogv
phasing_vlogvsqs[i] = phasing.vlogvsq
pmf = PI * (mass1 + mass2)*MTSUN_SI * f0
pmf13 = pmf**(1./3.)
mapping = generate_inverse_mapping(order)
lambdas = []
lambda_str = '^Lambda([0-9]+)'
loglambda_str = '^LogLambda([0-9]+)'
logloglambda_str = '^LogLogLambda([0-9]+'
for idx in xrange(len(mapping.keys())):
# RE magic engage!
rematch = re.match(lambda_str, mapping[idx])
if rematch:
pn_order = int(rematch.groups()[0])
lambdas.append(phasing_vs[:,pn_order] * pmf13**(-5+pn_order))
continue
rematch = re.match(loglambda_str, mapping[idx])
if rematch:
pn_order = int(rematch.groups()[0])
lambdas.append(phasing_vlogvs[:,pn_order] * pmf13**(-5+pn_order))
continue
rematch = re.match(logloglambda_str, mapping[idx])
if rematch:
pn_order = int(rematch.groups()[0])
lambdas.append(phasing_vlogvsqs[:,pn_order] * pmf13**(-5+pn_order))
continue
err_msg = "Failed to parse " + mapping[idx]
raise ValueError(err_msg)
if sngl_inp:
return [l[0] for l in lambdas]
else:
return lambdas