def generate_LAL_modes(approximant, q, chiA0, chiB0, dt, M, \
dist_mpc, f_low, f_ref, phi_ref, ellMax=None):
distance = dist_mpc * 1.0e6 * PC_SI
approxTag = lalsim.SimInspiralGetApproximantFromString(approximant)
# component masses of the binary
m1_kg = M * MSUN_SI * q / (1. + q)
m2_kg = M * MSUN_SI / (1. + q)
dictParams = lal.CreateDict()
if ellMax is not None:
ma = lalsim.SimInspiralCreateModeArray()
for ell in range(2, ellMax + 1):
lalsim.SimInspiralModeArrayActivateAllModesAtL(ma, ell)
lalsim.SimInspiralWaveformParamsInsertModeArray(dictParams, ma)
lmax = 5 # This in unused
hmodes = lalsim.SimInspiralChooseTDModes(phi_ref, dt, m1_kg, m2_kg, \
chiA0[0], chiA0[1], chiA0[2], chiB0[0], chiB0[1], chiB0[2], \
f_low, f_ref, distance, dictParams, lmax, approxTag)
t = np.arange(len(hmodes.mode.data.data)) * dt
mode_dict = {}
while hmodes is not None:
mode_dict['h_l%dm%d' % (hmodes.l, hmodes.m)] = hmodes.mode.data.data
hmodes = hmodes.next
return t, mode_dict
def gen_test_data(spin1x, approximant, mode_array):
"""
compute the difference between two waveforms
and compare to expected value
"""
lalparams = lal.CreateDict()
if (mode_array != None):
ModeArray = lalsimulation.SimInspiralCreateModeArray()
for mode in mode_array:
lalsimulation.SimInspiralModeArrayActivateMode(
ModeArray, mode[0], mode[1])
lalsimulation.SimInspiralWaveformParamsInsertModeArray(
lalparams, ModeArray)
common_pars = dict(m1=50 * lal.MSUN_SI,
m2=30 * lal.MSUN_SI,
s1x=spin1x,
s1y=0.,
s1z=0.,
s2x=0.,
s2y=0.,
s2z=0.,
distance=1,
inclination=np.pi / 3.,
phiRef=0.,
longAscNodes=0.,
eccentricity=0.,
meanPerAno=0.,
deltaT=1. / 4096.,
f_min=30.,
f_ref=30.,
params=lalparams,
approximant=approximant)
pars1 = common_pars.copy()
pars2 = common_pars.copy()
pars2.update({"inclination": 0.17})
pars2.update({"phiRef": 0.5})
hp1, hc1 = lalsimulation.SimInspiralChooseTDWaveform(**pars1)
hp2, hc2 = lalsimulation.SimInspiralChooseTDWaveform(**pars2)
# compute amp and phase
hp1_amp, hp1_phase = get_amp_phase(hp1.data.data)
hc1_amp, hc1_phase = get_amp_phase(hc1.data.data)
hp2_amp, hp2_phase = get_amp_phase(hp2.data.data)
hc2_amp, hc2_phase = get_amp_phase(hc2.data.data)
hp_amp_diff = sum_sqr_diff(hp1_amp, hp2_amp)
hp_phase_diff = sum_sqr_diff(hp1_phase, hp2_phase)
hc_amp_diff = sum_sqr_diff(hc1_amp, hc2_amp)
hc_phase_diff = sum_sqr_diff(hc1_phase, hc2_phase)
return hp_amp_diff, hp_phase_diff, hc_amp_diff, hc_phase_diff
def set_single_mode(params, l, m):
""" Sets modes in params dict.
Only adds (l,m) and (l,-m) modes.
"""
# First, create the 'empty' mode array
ma = lalsim.SimInspiralCreateModeArray()
# add (l,m) and (l,-m) modes
lalsim.SimInspiralModeArrayActivateMode(ma, l, m)
lalsim.SimInspiralModeArrayActivateMode(ma, l, -m)
#then insert your ModeArray into the LALDict params with
lalsim.SimInspiralWaveformParamsInsertModeArray(params, ma)
return params
def generate_LAL_waveform(approximant, q, chiA0, chiB0, dt, M, \
dist_mpc, f_low, f_ref, inclination=0, phi_ref=0., ellMax=None, \
single_mode=None):
distance = dist_mpc * 1.0e6 * PC_SI
approxTag = lalsim.SimInspiralGetApproximantFromString(approximant)
# component masses of the binary
m1_kg = M * MSUN_SI * q / (1. + q)
m2_kg = M * MSUN_SI / (1. + q)
if single_mode is not None and ellMax is not None:
raise Exception("Specify only one of single_mode or ellMax")
dictParams = lal.CreateDict()
# If ellMax, load all modes with ell<=ellMax
if ellMax is not None:
ma = lalsim.SimInspiralCreateModeArray()
for ell in range(2, ellMax + 1):
lalsim.SimInspiralModeArrayActivateAllModesAtL(ma, ell)
lalsim.SimInspiralWaveformParamsInsertModeArray(dictParams, ma)
elif single_mode is not None:
# If a single_mode is given, load only that mode (l,m) and (l,-m)
dictParams = set_single_mode(dictParams, single_mode[0],
single_mode[1])
hp, hc = lalsim.SimInspiralChooseTDWaveform(\
m1_kg, m2_kg, chiA0[0], chiA0[1], chiA0[2], \
chiB0[0], chiB0[1], chiB0[2], \
distance, inclination, phi_ref, 0, 0, 0,\
dt, f_low, f_ref, dictParams, approxTag)
h = np.array(hp.data.data - 1.j * hc.data.data)
t = dt * np.arange(len(h))
return t, h
def _check_lal_pars(p):
""" Create a laldict object from the dictionary of waveform parameters
Parameters
----------
p: dictionary
The dictionary of lalsimulation paramaters
Returns
-------
laldict: LalDict
The lal type dictionary to pass to the lalsimulation waveform functions.
"""
lal_pars = lal.CreateDict()
#nonGRparams can be straightforwardly added if needed, however they have to
# be invoked one by one
if p['phase_order']!=-1:
lalsimulation.SimInspiralWaveformParamsInsertPNPhaseOrder(lal_pars,int(p['phase_order']))
if p['amplitude_order']!=-1:
lalsimulation.SimInspiralWaveformParamsInsertPNAmplitudeOrder(lal_pars,int(p['amplitude_order']))
if p['spin_order']!=-1:
lalsimulation.SimInspiralWaveformParamsInsertPNSpinOrder(lal_pars,int(p['spin_order']))
if p['tidal_order']!=-1:
lalsimulation.SimInspiralWaveformParamsInsertPNTidalOrder(lal_pars, p['tidal_order'])
if p['eccentricity_order']!=-1:
lalsimulation.SimInspiralWaveformParamsInsertPNEccentricityOrder(lal_pars, p['eccentricity_order'])
if p['lambda1'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertTidalLambda1(lal_pars, p['lambda1'])
if p['lambda2'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertTidalLambda2(lal_pars, p['lambda2'])
if p['lambda_octu1'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertTidalOctupolarLambda1(lal_pars, p['lambda_octu1'])
if p['lambda_octu2'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertTidalOctupolarLambda2(lal_pars, p['lambda_octu2'])
if p['quadfmode1'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertTidalQuadrupolarFMode1(lal_pars, p['quadfmode1'])
if p['quadfmode2'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertTidalQuadrupolarFMode2(lal_pars, p['quadfmode2'])
if p['octufmode1'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertTidalOctupolarFMode1(lal_pars, p['octufmode1'])
if p['octufmode2'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertTidalOctupolarFMode2(lal_pars, p['octufmode2'])
if p['dquad_mon1'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertdQuadMon1(lal_pars, p['dquad_mon1'])
if p['dquad_mon2'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertdQuadMon2(lal_pars, p['dquad_mon2'])
if p['numrel_data']:
lalsimulation.SimInspiralWaveformParamsInsertNumRelData(lal_pars, str(p['numrel_data']))
if p['modes_choice']:
lalsimulation.SimInspiralWaveformParamsInsertModesChoice(lal_pars, p['modes_choice'])
if p['frame_axis']:
lalsimulation.SimInspiralWaveformParamsInsertFrameAxis(lal_pars, p['frame_axis'])
if p['side_bands']:
lalsimulation.SimInspiralWaveformParamsInsertSideband(lal_pars, p['side_bands'])
if p['mode_array'] is not None:
ma = lalsimulation.SimInspiralCreateModeArray()
for l,m in p['mode_array']:
lalsimulation.SimInspiralModeArrayActivateMode(ma, l, m)
lalsimulation.SimInspiralWaveformParamsInsertModeArray(lal_pars, ma)
#TestingGR parameters:
if p['dchi0'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertNonGRDChi0(lal_pars,p['dchi0'])
if p['dchi1'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertNonGRDChi1(lal_pars,p['dchi1'])
if p['dchi2'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertNonGRDChi2(lal_pars,p['dchi2'])
if p['dchi3'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertNonGRDChi3(lal_pars,p['dchi3'])
if p['dchi4'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertNonGRDChi4(lal_pars,p['dchi4'])
if p['dchi5'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertNonGRDChi5(lal_pars,p['dchi5'])
if p['dchi5l'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertNonGRDChi5L(lal_pars,p['dchi5l'])
if p['dchi6'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertNonGRDChi6(lal_pars,p['dchi6'])
if p['dchi6l'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertNonGRDChi6L(lal_pars,p['dchi6l'])
if p['dchi7'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertNonGRDChi7(lal_pars,p['dchi7'])
if p['dalpha1'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertNonGRDAlpha1(lal_pars,p['dalpha1'])
if p['dalpha2'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertNonGRDAlpha2(lal_pars,p['dalpha2'])
if p['dalpha3'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertNonGRDAlpha3(lal_pars,p['dalpha3'])
if p['dalpha4'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertNonGRDAlpha4(lal_pars,p['dalpha4'])
if p['dalpha5'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertNonGRDAlpha5(lal_pars,p['dalpha5'])
if p['dbeta1'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertNonGRDBeta1(lal_pars,p['dbeta1'])
if p['dbeta2'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertNonGRDBeta2(lal_pars,p['dbeta2'])
if p['dbeta3'] is not None:
lalsimulation.SimInspiralWaveformParamsInsertNonGRDBeta3(lal_pars,p['dbeta3'])
return lal_pars
def _base_lal_cbc_fd_waveform(
frequency_array, mass_1, mass_2, luminosity_distance, theta_jn, phase,
a_1=0.0, a_2=0.0, tilt_1=0.0, tilt_2=0.0, phi_12=0.0, phi_jl=0.0,
lambda_1=0.0, lambda_2=0.0, eccentricity=0.0, **waveform_kwargs):
""" Generate a cbc waveform model using lalsimulation
Parameters
==========
frequency_array: array_like
The frequencies at which we want to calculate the strain
mass_1: float
The mass of the heavier object in solar masses
mass_2: float
The mass of the lighter object in solar masses
luminosity_distance: float
The luminosity distance in megaparsec
a_1: float
Dimensionless primary spin magnitude
tilt_1: float
Primary tilt angle
phi_12: float
Azimuthal angle between the component spins
a_2: float
Dimensionless secondary spin magnitude
tilt_2: float
Secondary tilt angle
phi_jl: float
Azimuthal angle between the total and orbital angular momenta
theta_jn: float
Orbital inclination
phase: float
The phase at coalescence
eccentricity: float
Binary eccentricity
lambda_1: float
Tidal deformability of the more massive object
lambda_2: float
Tidal deformability of the less massive object
kwargs: dict
Optional keyword arguments
Returns
=======
dict: A dictionary with the plus and cross polarisation strain modes
"""
import lal
import lalsimulation as lalsim
waveform_approximant = waveform_kwargs['waveform_approximant']
reference_frequency = waveform_kwargs['reference_frequency']
minimum_frequency = waveform_kwargs['minimum_frequency']
maximum_frequency = waveform_kwargs['maximum_frequency']
catch_waveform_errors = waveform_kwargs['catch_waveform_errors']
pn_spin_order = waveform_kwargs['pn_spin_order']
pn_tidal_order = waveform_kwargs['pn_tidal_order']
pn_phase_order = waveform_kwargs['pn_phase_order']
pn_amplitude_order = waveform_kwargs['pn_amplitude_order']
waveform_dictionary = waveform_kwargs.get(
'lal_waveform_dictionary', lal.CreateDict()
)
approximant = lalsim_GetApproximantFromString(waveform_approximant)
if pn_amplitude_order != 0:
start_frequency = lalsim.SimInspiralfLow2fStart(
minimum_frequency, int(pn_amplitude_order), approximant)
else:
start_frequency = minimum_frequency
delta_frequency = frequency_array[1] - frequency_array[0]
frequency_bounds = ((frequency_array >= minimum_frequency) *
(frequency_array <= maximum_frequency))
luminosity_distance = luminosity_distance * 1e6 * utils.parsec
mass_1 = mass_1 * utils.solar_mass
mass_2 = mass_2 * utils.solar_mass
iota, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z = bilby_to_lalsimulation_spins(
theta_jn=theta_jn, phi_jl=phi_jl, tilt_1=tilt_1, tilt_2=tilt_2,
phi_12=phi_12, a_1=a_1, a_2=a_2, mass_1=mass_1, mass_2=mass_2,
reference_frequency=reference_frequency, phase=phase)
longitude_ascending_nodes = 0.0
mean_per_ano = 0.0
lalsim.SimInspiralWaveformParamsInsertPNSpinOrder(
waveform_dictionary, int(pn_spin_order))
lalsim.SimInspiralWaveformParamsInsertPNTidalOrder(
waveform_dictionary, int(pn_tidal_order))
lalsim.SimInspiralWaveformParamsInsertPNPhaseOrder(
waveform_dictionary, int(pn_phase_order))
lalsim.SimInspiralWaveformParamsInsertPNAmplitudeOrder(
waveform_dictionary, int(pn_amplitude_order))
lalsim_SimInspiralWaveformParamsInsertTidalLambda1(
waveform_dictionary, lambda_1)
lalsim_SimInspiralWaveformParamsInsertTidalLambda2(
waveform_dictionary, lambda_2)
for key, value in waveform_kwargs.items():
func = getattr(lalsim, "SimInspiralWaveformParamsInsert" + key, None)
if func is not None:
func(waveform_dictionary, value)
if waveform_kwargs.get('numerical_relativity_file', None) is not None:
lalsim.SimInspiralWaveformParamsInsertNumRelData(
waveform_dictionary, waveform_kwargs['numerical_relativity_file'])
if ('mode_array' in waveform_kwargs) and waveform_kwargs['mode_array'] is not None:
mode_array = waveform_kwargs['mode_array']
mode_array_lal = lalsim.SimInspiralCreateModeArray()
for mode in mode_array:
lalsim.SimInspiralModeArrayActivateMode(mode_array_lal, mode[0], mode[1])
lalsim.SimInspiralWaveformParamsInsertModeArray(waveform_dictionary, mode_array_lal)
if lalsim.SimInspiralImplementedFDApproximants(approximant):
wf_func = lalsim_SimInspiralChooseFDWaveform
else:
wf_func = lalsim_SimInspiralFD
try:
hplus, hcross = wf_func(
mass_1, mass_2, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y,
spin_2z, luminosity_distance, iota, phase,
longitude_ascending_nodes, eccentricity, mean_per_ano, delta_frequency,
start_frequency, maximum_frequency, reference_frequency,
waveform_dictionary, approximant)
except Exception as e:
if not catch_waveform_errors:
raise
else:
EDOM = (e.args[0] == 'Internal function call failed: Input domain error')
if EDOM:
failed_parameters = dict(mass_1=mass_1, mass_2=mass_2,
spin_1=(spin_1x, spin_2y, spin_1z),
spin_2=(spin_2x, spin_2y, spin_2z),
luminosity_distance=luminosity_distance,
iota=iota, phase=phase,
eccentricity=eccentricity,
start_frequency=start_frequency)
logger.warning("Evaluating the waveform failed with error: {}\n".format(e) +
"The parameters were {}\n".format(failed_parameters) +
"Likelihood will be set to -inf.")
return None
else:
raise
h_plus = np.zeros_like(frequency_array, dtype=complex)
h_cross = np.zeros_like(frequency_array, dtype=complex)
if len(hplus.data.data) > len(frequency_array):
logger.debug("LALsim waveform longer than bilby's `frequency_array`" +
"({} vs {}), ".format(len(hplus.data.data), len(frequency_array)) +
"probably because padded with zeros up to the next power of two length." +
" Truncating lalsim array.")
h_plus = hplus.data.data[:len(h_plus)]
h_cross = hcross.data.data[:len(h_cross)]
else:
h_plus[:len(hplus.data.data)] = hplus.data.data
h_cross[:len(hcross.data.data)] = hcross.data.data
h_plus *= frequency_bounds
h_cross *= frequency_bounds
if wf_func == lalsim_SimInspiralFD:
dt = 1 / hplus.deltaF + (hplus.epoch.gpsSeconds + hplus.epoch.gpsNanoSeconds * 1e-9)
time_shift = np.exp(-1j * 2 * np.pi * dt * frequency_array[frequency_bounds])
h_plus[frequency_bounds] *= time_shift
h_cross[frequency_bounds] *= time_shift
return dict(plus=h_plus, cross=h_cross)
def _base_waveform_frequency_sequence(frequency_array, mass_1, mass_2,
luminosity_distance, a_1, tilt_1, phi_12,
a_2, tilt_2, lambda_1, lambda_2, phi_jl,
theta_jn, phase, **waveform_kwargs):
""" Generate a cbc waveform model on specified frequency samples
Parameters
----------
frequency_array: np.array
This input is ignored
mass_1: float
The mass of the heavier object in solar masses
mass_2: float
The mass of the lighter object in solar masses
luminosity_distance: float
The luminosity distance in megaparsec
a_1: float
Dimensionless primary spin magnitude
tilt_1: float
Primary tilt angle
phi_12: float
a_2: float
Dimensionless secondary spin magnitude
tilt_2: float
Secondary tilt angle
phi_jl: float
theta_jn: float
Orbital inclination
phase: float
The phase at coalescence
waveform_kwargs: dict
Optional keyword arguments
Returns
-------
waveform_polarizations: dict
Dict containing plus and cross modes evaluated at the linear and
quadratic frequency nodes.
"""
from lal import CreateDict
import lalsimulation as lalsim
frequencies = waveform_kwargs['frequencies']
reference_frequency = waveform_kwargs['reference_frequency']
approximant = lalsim_GetApproximantFromString(
waveform_kwargs['waveform_approximant'])
catch_waveform_errors = waveform_kwargs['catch_waveform_errors']
pn_spin_order = waveform_kwargs['pn_spin_order']
pn_tidal_order = waveform_kwargs['pn_tidal_order']
pn_phase_order = waveform_kwargs['pn_phase_order']
pn_amplitude_order = waveform_kwargs['pn_amplitude_order']
waveform_dictionary = waveform_kwargs.get('lal_waveform_dictionary',
CreateDict())
lalsim.SimInspiralWaveformParamsInsertPNSpinOrder(waveform_dictionary,
int(pn_spin_order))
lalsim.SimInspiralWaveformParamsInsertPNTidalOrder(waveform_dictionary,
int(pn_tidal_order))
lalsim.SimInspiralWaveformParamsInsertPNPhaseOrder(waveform_dictionary,
int(pn_phase_order))
lalsim.SimInspiralWaveformParamsInsertPNAmplitudeOrder(
waveform_dictionary, int(pn_amplitude_order))
lalsim_SimInspiralWaveformParamsInsertTidalLambda1(waveform_dictionary,
lambda_1)
lalsim_SimInspiralWaveformParamsInsertTidalLambda2(waveform_dictionary,
lambda_2)
for key, value in waveform_kwargs.items():
func = getattr(lalsim, "SimInspiralWaveformParamsInsert" + key, None)
if func is not None:
func(waveform_dictionary, value)
if waveform_kwargs.get('numerical_relativity_file', None) is not None:
lalsim.SimInspiralWaveformParamsInsertNumRelData(
waveform_dictionary, waveform_kwargs['numerical_relativity_file'])
if ('mode_array'
in waveform_kwargs) and waveform_kwargs['mode_array'] is not None:
mode_array = waveform_kwargs['mode_array']
mode_array_lal = lalsim.SimInspiralCreateModeArray()
for mode in mode_array:
lalsim.SimInspiralModeArrayActivateMode(mode_array_lal, mode[0],
mode[1])
lalsim.SimInspiralWaveformParamsInsertModeArray(
waveform_dictionary, mode_array_lal)
luminosity_distance = luminosity_distance * 1e6 * utils.parsec
mass_1 = mass_1 * utils.solar_mass
mass_2 = mass_2 * utils.solar_mass
iota, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z = bilby_to_lalsimulation_spins(
theta_jn=theta_jn,
phi_jl=phi_jl,
tilt_1=tilt_1,
tilt_2=tilt_2,
phi_12=phi_12,
a_1=a_1,
a_2=a_2,
mass_1=mass_1,
mass_2=mass_2,
reference_frequency=reference_frequency,
phase=phase)
try:
h_plus, h_cross = lalsim_SimInspiralChooseFDWaveformSequence(
phase, mass_1, mass_2, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y,
spin_2z, reference_frequency, luminosity_distance, iota,
waveform_dictionary, approximant, frequencies)
except Exception as e:
if not catch_waveform_errors:
raise
else:
EDOM = (e.args[0] ==
'Internal function call failed: Input domain error')
if EDOM:
failed_parameters = dict(
mass_1=mass_1,
mass_2=mass_2,
spin_1=(spin_1x, spin_2y, spin_1z),
spin_2=(spin_2x, spin_2y, spin_2z),
luminosity_distance=luminosity_distance,
iota=iota,
phase=phase)
logger.warning(
"Evaluating the waveform failed with error: {}\n".format(e)
+ "The parameters were {}\n".format(failed_parameters) +
"Likelihood will be set to -inf.")
return None
else:
raise
return dict(plus=h_plus.data.data, cross=h_cross.data.data)
def _base_lal_cbc_fd_waveform(frequency_array,
mass_1,
mass_2,
luminosity_distance,
theta_jn,
phase,
a_1=0.0,
a_2=0.0,
tilt_1=0.0,
tilt_2=0.0,
phi_12=0.0,
phi_jl=0.0,
lambda_1=0.0,
lambda_2=0.0,
eccentricity=0.0,
**waveform_kwargs):
""" Generate a cbc waveform model using lalsimulation
Parameters
----------
frequency_array: array_like
The frequencies at which we want to calculate the strain
mass_1: float
The mass of the heavier object in solar masses
mass_2: float
The mass of the lighter object in solar masses
luminosity_distance: float
The luminosity distance in megaparsec
a_1: float
Dimensionless primary spin magnitude
tilt_1: float
Primary tilt angle
phi_12: float
Azimuthal angle between the component spins
a_2: float
Dimensionless secondary spin magnitude
tilt_2: float
Secondary tilt angle
phi_jl: float
Azimuthal angle between the total and orbital angular momenta
theta_jn: float
Orbital inclination
phase: float
The phase at coalescence
eccentricity: float
Binary eccentricity
lambda_1: float
Tidal deformability of the more massive object
lambda_2: float
Tidal deformability of the less massive object
kwargs: dict
Optional keyword arguments
Returns
-------
dict: A dictionary with the plus and cross polarisation strain modes
"""
waveform_approximant = waveform_kwargs['waveform_approximant']
reference_frequency = waveform_kwargs['reference_frequency']
minimum_frequency = waveform_kwargs['minimum_frequency']
maximum_frequency = waveform_kwargs['maximum_frequency']
catch_waveform_errors = waveform_kwargs['catch_waveform_errors']
pn_spin_order = waveform_kwargs['pn_spin_order']
pn_tidal_order = waveform_kwargs['pn_tidal_order']
pn_phase_order = waveform_kwargs['pn_phase_order']
pn_amplitude_order = waveform_kwargs['pn_amplitude_order']
approximant = lalsim_GetApproximantFromString(waveform_approximant)
if pn_amplitude_order != 0:
start_frequency = lalsim.SimInspiralfLow2fStart(
minimum_frequency, int(pn_amplitude_order), approximant)
else:
start_frequency = minimum_frequency
delta_frequency = frequency_array[1] - frequency_array[0]
frequency_bounds = ((frequency_array >= minimum_frequency) *
(frequency_array <= maximum_frequency))
luminosity_distance = luminosity_distance * 1e6 * utils.parsec
mass_1 = mass_1 * utils.solar_mass
mass_2 = mass_2 * utils.solar_mass
iota, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z = bilby_to_lalsimulation_spins(
theta_jn=theta_jn,
phi_jl=phi_jl,
tilt_1=tilt_1,
tilt_2=tilt_2,
phi_12=phi_12,
a_1=a_1,
a_2=a_2,
mass_1=mass_1,
mass_2=mass_2,
reference_frequency=reference_frequency,
phase=phase)
longitude_ascending_nodes = 0.0
mean_per_ano = 0.0
waveform_dictionary = lal.CreateDict()
lalsim.SimInspiralWaveformParamsInsertPNSpinOrder(waveform_dictionary,
int(pn_spin_order))
lalsim.SimInspiralWaveformParamsInsertPNTidalOrder(waveform_dictionary,
int(pn_tidal_order))
lalsim.SimInspiralWaveformParamsInsertPNPhaseOrder(waveform_dictionary,
int(pn_phase_order))
lalsim.SimInspiralWaveformParamsInsertPNAmplitudeOrder(
waveform_dictionary, int(pn_amplitude_order))
lalsim_SimInspiralWaveformParamsInsertTidalLambda1(waveform_dictionary,
lambda_1)
lalsim_SimInspiralWaveformParamsInsertTidalLambda2(waveform_dictionary,
lambda_2)
if 'modearray' in waveform_kwargs:
modearray = waveform_kwargs['modearray']
mode_array = lalsim.SimInspiralCreateModeArray()
for mode in modearray:
lalsim.SimInspiralModeArrayActivateMode(mode_array, mode[0],
mode[1])
lalsim.SimInspiralWaveformParamsInsertModeArray(
waveform_dictionary, mode_array)
if lalsim.SimInspiralImplementedFDApproximants(approximant):
wf_func = lalsim_SimInspiralChooseFDWaveform
else:
wf_func = lalsim_SimInspiralFD
try:
hplus, hcross = wf_func(mass_1, mass_2, spin_1x, spin_1y, spin_1z,
spin_2x, spin_2y, spin_2z, luminosity_distance,
iota, phase, longitude_ascending_nodes,
eccentricity, mean_per_ano, delta_frequency,
start_frequency, maximum_frequency,
reference_frequency, waveform_dictionary,
approximant)
except Exception as e:
if not catch_waveform_errors:
raise
else:
EDOM = (e.args[0] ==
'Internal function call failed: Input domain error')
if EDOM:
failed_parameters = dict(
mass_1=mass_1,
mass_2=mass_2,
spin_1=(spin_1x, spin_2y, spin_1z),
spin_2=(spin_2x, spin_2y, spin_2z),
luminosity_distance=luminosity_distance,
iota=iota,
phase=phase,
eccentricity=eccentricity,
start_frequency=start_frequency)
logger.warning(
"Evaluating the waveform failed with error: {}\n".format(e)
+ "The parameters were {}\n".format(failed_parameters) +
"Likelihood will be set to -inf.")
return None
else:
raise
h_plus = np.zeros_like(frequency_array, dtype=np.complex)
h_cross = np.zeros_like(frequency_array, dtype=np.complex)
if len(hplus.data.data) > len(frequency_array):
raise ValueError("Waveform longer than frequency array")
h_plus[:len(hplus.data.data)] = hplus.data.data
h_cross[:len(hcross.data.data)] = hcross.data.data
h_plus *= frequency_bounds
h_cross *= frequency_bounds
return dict(plus=h_plus, cross=h_cross)
