def _lalsim_fd_waveform(**p):
flags = lalsimulation.SimInspiralCreateWaveformFlags()
lalsimulation.SimInspiralSetSpinOrder(flags, p['spin_order'])
lalsimulation.SimInspiralSetTidalOrder(flags, p['tidal_order'])
hp, hc = lalsimulation.SimInspiralChooseFDWaveform(
float(p['coa_phase']), float(p['delta_f']),
float(pnutils.solar_mass_to_kg(p['mass1'])),
float(pnutils.solar_mass_to_kg(p['mass2'])), float(p['spin1x']),
float(p['spin1y']), float(p['spin1z']), float(p['spin2x']),
float(p['spin2y']), float(p['spin2z']), float(p['f_lower']),
float(p['f_final']), float(p['f_ref']),
pnutils.megaparsecs_to_meters(float(p['distance'])),
float(p['inclination']), float(p['lambda1']),
float(p['lambda2']), flags, None, int(p['amplitude_order']),
int(p['phase_order']), _lalsim_enum[p['approximant']])
hp = FrequencySeries(hp.data.data[:] * 1,
delta_f=hp.deltaF,
epoch=hp.epoch)
hc = FrequencySeries(hc.data.data[:] * 1,
delta_f=hc.deltaF,
epoch=hc.epoch)
return hp, hc
def _compute_waveform(self, df, f_final):
"""
The ROM is a frequency domain waveform, so easier.
"""
# get hptilde
approx_enum = lalsim.GetApproximantFromString(
'SEOBNRv2_ROM_DoubleSpin')
flags = lalsim.SimInspiralCreateWaveformFlags()
htilde, _ = lalsim.SimInspiralChooseFDWaveform(
0, df, self.m1 * MSUN_SI, self.m2 * MSUN_SI, 0., 0., self.spin1z,
0., 0., self.spin2z, self.bank.flow, f_final, self.bank.flow,
1e6 * PC_SI, 0., 0., 0., flags, None, 1, 8, approx_enum)
return htilde
def _lalsim_fd_waveform(**p):
flags = lalsimulation.SimInspiralCreateWaveformFlags()
lalsimulation.SimInspiralSetSpinOrder(flags, p['spin_order'])
lalsimulation.SimInspiralSetTidalOrder(flags, p['tidal_order'])
#------------------------------------------------
# SM: Added to pull out harmonics
#------------------------------------------------
if p['sideband'] != None:
nonGRparams = lalsimulation.SimInspiralCreateTestGRParam(
'sideband', p['sideband'])
else:
nonGRparams = None
hp, hc = lalsimulation.SimInspiralChooseFDWaveform(
float(p['coa_phase']),
float(p['delta_f']),
float(pnutils.solar_mass_to_kg(p['mass1'])),
float(pnutils.solar_mass_to_kg(p['mass2'])),
float(p['spin1x']),
float(p['spin1y']),
float(p['spin1z']),
float(p['spin2x']),
float(p['spin2y']),
float(p['spin2z']),
float(p['f_lower']),
float(p['f_final']),
float(p['f_ref']),
pnutils.megaparsecs_to_meters(float(p['distance'])),
float(p['inclination']),
float(p['lambda1']),
float(p['lambda2']),
flags,
nonGRparams, #Replaced flags, None > flags, nonGRparams
int(p['amplitude_order']),
int(p['phase_order']),
_lalsim_enum[p['approximant']])
hp = FrequencySeries(hp.data.data[:] * 1,
delta_f=hp.deltaF,
epoch=hp.epoch)
hc = FrequencySeries(hc.data.data[:] * 1,
delta_f=hc.deltaF,
epoch=hc.epoch)
return hp, hc
def _compute_waveform(self, df, f_final):
flags = lalsim.SimInspiralCreateWaveformFlags()
phi0 = 0 # This is a reference phase, and not an intrinsic parameter
lmbda1 = lmbda2 = 0 # No tidal terms here
ampO = -1 # Are these the correct values??
phaseO = -1 # Are these the correct values??
approx = lalsim.GetApproximantFromString(self.approximant)
if lalsim.SimInspiralImplementedFDApproximants(approx):
hplus_fd, hcross_fd = lalsim.SimInspiralChooseFDWaveform(
0, df, self.m1 * MSUN_SI, self.m2 * MSUN_SI, 0., 0.,
self.spin1z, 0., 0., self.spin2z, self.bank.flow, f_final,
self.bank.flow, 1e6 * PC_SI, 0., 0., 0., flags, None, ampO,
phaseO, approx)
else:
hplus_fd, hcross_fd = lalsim.SimInspiralFD(
phi0,
df,
self.m1 * MSUN_SI,
self.m2 * MSUN_SI,
0,
0,
self.spin1z,
0,
0,
self.spin2z,
self.bank.flow,
f_final,
40.0,
1e6 * PC_SI,
0,
0,
lmbda1,
lmbda2, # irrelevant parameters for BBH
None,
None, # non-GR parameters
ampO,
phaseO,
approx)
return hplus_fd
def _lalsim_td_waveform(**p):
flags = lalsimulation.SimInspiralCreateWaveformFlags()
lalsimulation.SimInspiralSetSpinOrder(flags, p['spin_order'])
lalsimulation.SimInspiralSetTidalOrder(flags, p['tidal_order'])
###########
def rulog2(val):
return 2.0**numpy.ceil(numpy.log2(float(val)))
f_final = rulog2(seobnrrom_final_frequency(**p))
f_nyq = 0.5 / p['delta_t']
if f_final > f_nyq:
print 'Final frequecny {0} is greater than given nyquist frequecny {1}'.format(
f_final, f_nyq)
p['delta_t'] = 0.5 / f_final
##########
if p['numrel_data']:
lalsimulation.SimInspiralSetNumrelData(flags, str(p['numrel_data']))
hp1, hc1 = lalsimulation.SimInspiralChooseTDWaveform(
float(p['coa_phase']), float(p['delta_t']),
float(pnutils.solar_mass_to_kg(p['mass1'])),
float(pnutils.solar_mass_to_kg(p['mass2'])), float(p['spin1x']),
float(p['spin1y']), float(p['spin1z']), float(p['spin2x']),
float(p['spin2y']), float(p['spin2z']), float(p['f_lower']),
float(p['f_ref']), pnutils.megaparsecs_to_meters(float(p['distance'])),
float(p['inclination']), float(p['lambda1']),
float(p['lambda2']), flags, None, int(p['amplitude_order']),
int(p['phase_order']), _lalsim_enum[p['approximant']])
hp = TimeSeries(hp1.data.data[:], delta_t=hp1.deltaT, epoch=hp1.epoch)
hc = TimeSeries(hc1.data.data[:], delta_t=hc1.deltaT, epoch=hc1.epoch)
if f_final > f_nyq:
p['delta_t'] = 0.5 / f_nyq
print "Need to resample at delta_t {0}".format(p['delta_t'])
hp = resample_to_delta_t(hp, p['delta_t'])
hc = resample_to_delta_t(hc, p['delta_t'])
return hp, hc
def get_fd_waveform_sequence(template=None, **kwds):
"""Return values of the waveform evaluated at the sequence of frequency
points.
Parameters
----------
template: object
An object that has attached properties. This can be used to substitute
for keyword arguments. A common example would be a row in an xml table.
{params}
Returns
-------
hplustilde: Array
The plus phase of the waveform in frequency domain evaluated at the
frequency points.
hcrosstilde: Array
The cross phase of the waveform in frequency domain evaluated at the
frequency points.
"""
kwds['delta_f'] = -1
kwds['f_lower'] = -1
p = props(template, **kwds)
flags = lalsimulation.SimInspiralCreateWaveformFlags()
lalsimulation.SimInspiralSetSpinOrder(flags, p['spin_order'])
lalsimulation.SimInspiralSetTidalOrder(flags, p['tidal_order'])
hp, hc = lalsimulation.SimInspiralChooseFDWaveformSequence(
float(p['coa_phase']), float(pnutils.solar_mass_to_kg(p['mass1'])),
float(pnutils.solar_mass_to_kg(p['mass2'])), float(p['spin1x']),
float(p['spin1y']), float(p['spin1z']), float(p['spin2x']),
float(p['spin2y']), float(p['spin2z']), float(p['f_ref']),
pnutils.megaparsecs_to_meters(float(p['distance'])),
float(p['inclination']), float(p['lambda1']),
float(p['lambda2']), flags, None, int(p['amplitude_order']),
int(p['phase_order']), _lalsim_enum[p['approximant']],
p['sample_points'].lal())
return Array(hp.data.data), Array(hc.data.data)
def _compute_waveform(self, df, f_final):
phi0 = 0 # This is a reference phase, and not an intrinsic parameter
lmbda1 = lmbda2 = 0 # No tidal terms here
ampO = 0
phaseO = 7
approx = lalsim.GetApproximantFromString(self.approx_name)
wave_flags = lalsim.SimInspiralCreateWaveformFlags()
lalsim.SimInspiralSetSpinOrder(wave_flags, 5)
hplus_fd, hcross_fd = lalsim.SimInspiralChooseFDWaveform(
0,
df,
self.m1 * MSUN_SI,
self.m2 * MSUN_SI,
0,
0,
self.spin1z,
0,
0,
self.spin2z,
self.bank.flow,
f_final,
40.0,
1e6 * PC_SI,
0,
lmbda1,
lmbda2, # irrelevant parameters for BBH
wave_flags,
None, # non-GR parameters
ampO,
phaseO,
approx)
# Must set values greater than _get_f_final to 0
act_f_max = self._get_f_final()
f_max_idx = int(act_f_max / df + 0.999)
hplus_fd.data.data[f_max_idx:] = 0
return hplus_fd
def _lalsim_td_waveform(**p):
flags = lalsimulation.SimInspiralCreateWaveformFlags()
lalsimulation.SimInspiralSetSpinOrder(flags, p['spin_order'])
lalsimulation.SimInspiralSetTidalOrder(flags, p['tidal_order'])
if p['numrel_data']:
lalsimulation.SimInspiralSetNumrelData(flags, str(p['numrel_data']))
hp1, hc1 = lalsimulation.SimInspiralChooseTDWaveform(
float(p['coa_phase']), float(p['delta_t']),
float(pnutils.solar_mass_to_kg(p['mass1'])),
float(pnutils.solar_mass_to_kg(p['mass2'])), float(p['spin1x']),
float(p['spin1y']), float(p['spin1z']), float(p['spin2x']),
float(p['spin2y']), float(p['spin2z']), float(p['f_lower']),
float(p['f_ref']), pnutils.megaparsecs_to_meters(float(p['distance'])),
float(p['inclination']), float(p['lambda1']),
float(p['lambda2']), flags, None, int(p['amplitude_order']),
int(p['phase_order']), _lalsim_enum[p['approximant']])
hp = TimeSeries(hp1.data.data[:], delta_t=hp1.deltaT, epoch=hp1.epoch)
hc = TimeSeries(hc1.data.data[:], delta_t=hc1.deltaT, epoch=hc1.epoch)
return hp, hc
def test_taylorf2_array():
cl_context, cl_device, cl_queue = bagwacl_init()
tf2_kernels, BAGWACLTaylorF2Params_new, _ = taylorf2.init_kernels(
cl_context, cl_device)
## generate multiple waveforms and test each one against LAL/CPU code...
nwaveforms = 100
params = []
h_vecarray_cpu = []
# Other IFO data params
psdstart = 0
psdlength = 120000
trigtime = 6000
seglen = 10.
srate = 4096.
cbc_params_lst = []
for i in xrange(nwaveforms):
cbc_params = lalsupport.sample_cbc_params_from_prior()
cbc_params_lst.append(cbc_params)
li_cbc_params = lalsupport.create_livariables_from_cbc_params(
cbc_params)
params.append(BAGWACLTaylorF2Params_new())
(fStart, fEnd, deltaF) = t2_wfm_params_init(seglen, srate)
#(phic,deltaF,m1_SI,m2_SI,S1z,S2z,fStart,fEnd,distance_SI,lambda1,lambda2,spinO,tidalO,phaseO,amplitudeO)=generate_random_wfm_params()
taylorf2.tf2_pn_params_init(
params[i],
cbc_params.phase,
deltaF,
cbc_params.mass1 * LAL_MSUN_SI,
cbc_params.mass2 * LAL_MSUN_SI,
cbc_params.S1z,
cbc_params.S2z,
fStart,
fEnd,
cbc_params.distance * LAL_PC_SI * 1e6,
cbc_params.lambda1,
cbc_params.lambda2,
cbc_params.spinO,
cbc_params.tidalO,
cbc_params.LAL_PNORDER,
cbc_params.LAL_AMPORDER,
)
# Fake some interferometer data
#ifos=[
#['H1','LALSimAdLIGO',fStart,'DUMMY'],
#]
#data=lalsupport.generate_ifoData(
#ifos,
#psdstart,
#psdlength,
#seglen,
#trigtime,
#srate=4096.,
#)
#lalsupport.init_ifoData(data)
#data.modelParams=li_cbc_params
# Call equivalent LALSimulation/Inference CPU-only function
#lalinference.TemplateXLALSimInspiralChooseWaveform(data)
waveFlags = lalsimulation.SimInspiralCreateWaveformFlags()
lalsimulation.SimInspiralSetSpinOrder(
waveFlags, lalsimulation.LAL_SIM_INSPIRAL_SPINLESS)
lalsimulation.SimInspiralSetTidalOrder(
waveFlags, lalsimulation.LAL_SIM_INSPIRAL_TIDAL_ORDER_0PN)
h_vec_cpu, _ = lalsimulation.SimInspiralChooseFDWaveform(
cbc_params.phase,
deltaF,
cbc_params.mass1 * LAL_MSUN_SI,
cbc_params.mass2 * LAL_MSUN_SI,
cbc_params.S1x,
cbc_params.S1y,
cbc_params.S1z,
cbc_params.S2x,
cbc_params.S2y,
cbc_params.S2z,
fStart,
fEnd,
cbc_params.distance * LAL_PC_SI * 1e6,
cbc_params.inclination,
cbc_params.lambda1,
cbc_params.lambda2,
waveFlags,
None,
cbc_params.LAL_AMPORDER,
cbc_params.LAL_PNORDER,
cbc_params.LAL_APPROXIMANT,
)
# Extract output complex strain vector from LALSimulation output
h_vecarray_cpu.append(h_vec_cpu.data.data)
length = int(params[0]['n'][0])
params = np.array(params, dtype=params[0].dtype)
mem_pool = cl_tools.MemoryPool(
cl_tools.ImmediateAllocator(cl_queue, cl.mem_flags.READ_ONLY))
params_cl = cl.array.to_device(cl_queue, params)
hTilde_vecarray_cl = cl.array.zeros(cl_queue, (length * nwaveforms),
np.complex128)
tf2_kernels.BAGWACLTaylorF2threePointFivePN_array.set_scalar_arg_dtypes([
None,
None,
np.int32,
])
tf2_kernels.BAGWACLTaylorF2threePointFivePN_array(
cl_queue,
(
length,
nwaveforms,
),
None,
hTilde_vecarray_cl.data,
params_cl.data,
np.int32(0),
)
h_vecarray_gpu = hTilde_vecarray_cl.get()
np.savetxt(
'htilde_gpu.dat',
lalsupport.convert_bagwacl_templates_to_lal_templates(
h_vecarray_gpu[0:length], cbc_params_lst[-1].inclination)[0])
np.savetxt('htilde_cpu.dat', h_vecarray_cpu[0])
failure_count = 0
for i, h_vec_cpu in enumerate(h_vecarray_cpu):
h_vec_gpu, _ = lalsupport.convert_bagwacl_templates_to_lal_templates(
h_vecarray_gpu[i * length:(i + 1) * length],
cbc_params_lst[0].inclination)
try:
assert np.allclose(h_vec_cpu, h_vec_gpu, atol=0., rtol=1e-6)
except AssertionError:
failure_count += 1
print "Failure count is", failure_count
