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)