def get_waveform(approximant, phase_order, amplitude_order, template_params,
start_frequency, sample_rate, length, filter_rate):
if approximant in td_approximants():
hplus, hcross = get_td_waveform(template_params,
approximant=approximant,
phase_order=phase_order,
delta_t=1.0 / sample_rate,
f_lower=start_frequency,
amplitude_order=amplitude_order)
hvec = generate_detector_strain(template_params, hplus, hcross)
if filter_rate != sample_rate:
delta_t = 1.0 / filter_rate
hvec = resample_to_delta_t(hvec, delta_t)
elif approximant in fd_approximants():
delta_f = filter_rate / length
if hasattr(template_params, "spin1z") and hasattr(
template_params, "spin2z"):
if template_params.spin1z <= -0.9 or template_params.spin1z >= 0.9:
template_params.spin1z *= 0.99999999
if template_params.spin2z <= -0.9 or template_params.spin2z >= 0.9:
template_params.spin2z *= 0.99999999
if True:
print("\n spin1z = %f, spin2z = %f, chi = %f" %
(template_params.spin1z, template_params.spin2z,
lalsimulation.SimIMRPhenomBComputeChi(
template_params.mass1 * lal.LAL_MSUN_SI,
template_params.mass2 * lal.LAL_MSUN_SI,
template_params.spin1z, template_params.spin2z)),
file=sys.stderr)
print("spin1x = %f, spin1y = %f" %
(template_params.spin1x, template_params.spin1y),
file=sys.stderr)
print("spin2x = %f, spin2y = %f" %
(template_params.spin2x, template_params.spin2y),
file=sys.stderr)
print("m1 = %f, m2 = %f" %
(template_params.mass1, template_params.mass2),
file=sys.stderr)
hvec = get_fd_waveform(template_params,
approximant=approximant,
phase_order=phase_order,
delta_f=delta_f,
f_lower=start_frequency,
amplitude_order=amplitude_order)[0]
if True:
print("filter_N = %d in get waveform" % filter_N,
"\n type(hvec) in get_waveform:",
type(hvec),
file=sys.stderr)
print(hvec, file=sys.stderr)
print(hvec[0], file=sys.stderr)
print(hvec[1], file=sys.stderr)
print(isinstance(hvec, FrequencySeries), file=sys.stderr)
htilde = make_padded_frequency_series(hvec, filter_N)
return htilde
def pytest_addoption(parser):
"""Add --approximants command-line option
"""
parser.addoption('--approximants',
type=str,
nargs='*',
metavar='APPROX',
choices=sorted(fd_approximants()),
default=DEFAULT_APPROXIMANTS,
help='one or more approximant names to use in tests, '
'default: %(default)s, choices: %(choices)s')
def test_generation(self):
with self.context:
for waveform in td_approximants():
if waveform in failing_wfs:
continue
print(waveform)
hc,hp = get_td_waveform(approximant=waveform,mass1=20,mass2=20,delta_t=1.0/4096,f_lower=40)
self.assertTrue(len(hc)> 0)
for waveform in fd_approximants():
if waveform in failing_wfs:
continue
print(waveform)
htilde, g = get_fd_waveform(approximant=waveform,mass1=20,mass2=20,delta_f=1.0/256,f_lower=40)
self.assertTrue(len(htilde)> 0)
def get_waveform(approximant, order, template_params, start_frequency, sample_rate, length):
if approximant in fd_approximants():
delta_f = float(sample_rate) / length
hvec = get_fd_waveform(template_params, approximant=approximant,
phase_order=order, delta_f=delta_f,
f_lower=start_frequency, amplitude_order=order)
if approximant in td_approximants():
hplus,hcross = get_td_waveform(template_params, approximant=approximant,
phase_order=order, delta_t=1.0 / sample_rate,
f_lower=start_frequency, amplitude_order=order)
hvec = hplus
htilde = make_padded_frequency_series(hvec,filter_N)
return htilde
def get_waveform(wf_params, start_frequency, sample_rate, length,
filter_rate, sky_max_template=False):
delta_f = filter_rate / float(length)
if wf_params.approximant in fd_approximants():
hp, hc = get_fd_waveform(wf_params, delta_f=delta_f,
f_lower=start_frequency)
elif wf_params.approximant in td_approximants():
hp, hc = get_td_waveform(wf_params, delta_t=1./sample_rate,
f_lower=start_frequency)
if not sky_max_template:
hvec = generate_detector_strain(wf_params, hp, hc)
return make_padded_frequency_series(hvec, length, delta_f=delta_f)
else:
return make_padded_frequency_series(hp, length, delta_f=delta_f), \
make_padded_frequency_series(hc, length, delta_f=delta_f)
def get_waveform(wf_params, start_frequency, sample_rate, length,
filter_rate, sky_max_template=False):
delta_f = filter_rate / float(length)
if wf_params.approximant in fd_approximants():
hp, hc = get_fd_waveform(wf_params, delta_f=delta_f,
f_lower=start_frequency)
elif wf_params.approximant in td_approximants():
hp, hc = get_td_waveform(wf_params, delta_t=1./sample_rate,
f_lower=start_frequency)
if not sky_max_template:
hvec = generate_detector_strain(wf_params, hp, hc)
return make_padded_frequency_series(hvec, length, delta_f=delta_f)
else:
return make_padded_frequency_series(hp, length, delta_f=delta_f), \
make_padded_frequency_series(hc, length, delta_f=delta_f)
def get_waveform(approximant, phase_order, amplitude_order, template_params, start_frequency, sample_rate, length):
if approximant in td_approximants():
hplus,hcross = get_td_waveform(template_params, approximant=approximant,
phase_order=phase_order, delta_t=1.0 / sample_rate,
f_lower=start_frequency, amplitude_order=amplitude_order)
hvec = generate_detector_strain(template_params, hplus, hcross)
elif approximant in fd_approximants():
delta_f = sample_rate / length
hvec = get_fd_waveform(template_params, approximant=approximant,
phase_order=phase_order, delta_f=delta_f,
f_lower=start_frequency, amplitude_order=amplitude_order)
htilde = make_padded_frequency_series(hvec,filter_N)
return htilde
def get_waveform(approximant, phase_order, amplitude_order, template_params, start_frequency, sample_rate, length):
if approximant in td_approximants():
hplus,hcross = get_td_waveform(template_params, approximant=approximant,
phase_order=phase_order, delta_t=1.0 / sample_rate,
f_lower=start_frequency, amplitude_order=amplitude_order)
hvec = generate_detector_strain(template_params, hplus, hcross)
elif approximant in fd_approximants():
delta_f = sample_rate / length
hvec = get_fd_waveform(template_params, approximant=approximant,
phase_order=phase_order, delta_f=delta_f,
f_lower=start_frequency, amplitude_order=amplitude_order)
htilde = make_padded_frequency_series(hvec,filter_N)
return htilde
def test_generation(self):
with self.context:
for waveform in td_approximants():
if waveform in failing_wfs:
continue
print(waveform)
hc, hp = get_td_waveform(approximant=waveform,
mass1=20,
mass2=20,
delta_t=1.0 / 4096,
f_lower=40)
self.assertTrue(len(hc) > 0)
for waveform in fd_approximants():
if waveform in failing_wfs:
continue
print(waveform)
htilde, g = get_fd_waveform(approximant=waveform,
mass1=20,
mass2=20,
delta_f=1.0 / 256,
f_lower=40)
self.assertTrue(len(htilde) > 0)
action='store',
type='int',
dest='devicenum',
default=0,
help=optparse.SUPPRESS_HELP)
parser.add_option('--show-plots',
action='store_true',
help='show the plots generated in this test suite')
parser.add_option('--save-plots',
action='store_true',
help='save the plots generated in this test suite')
parser.add_option('--approximant',
type='choice',
choices=td_approximants() + fd_approximants(),
help="Choices are %s" %
str(td_approximants() + fd_approximants()))
parser.add_option('--mass1',
type=float,
default=10,
help="[default: %default]")
parser.add_option('--mass2', type=float, default=9, help="[default: %default]")
parser.add_option('--spin1x',
type=float,
default=0,
help="[default: %default]")
parser.add_option('--spin1y',
type=float,
default=0,
def get_waveform(approximant,
phase_order,
amplitude_order,
spin_order,
template_params,
start_frequency,
sample_rate,
length,
datafile=None,
verbose=False):
#{{{
print("IN hERE")
delta_t = 1. / sample_rate
delta_f = 1. / length
filter_N = int(length)
filter_n = filter_N / 2 + 1
if approximant in fd_approximants() and 'Eccentric' not in approximant:
print("NORMAL FD WAVEFORM for", approximant)
delta_f = sample_rate / length
hplus, hcross = get_fd_waveform(template_params,
approximant=approximant,
spin_order=spin_order,
phase_order=phase_order,
delta_f=delta_f,
f_lower=start_frequency,
amplitude_order=amplitude_order)
elif approximant in td_approximants() and 'Eccentric' not in approximant:
print("NORMAL TD WAVEFORM for", approximant)
hplus, hcross = get_td_waveform(template_params,
approximant=approximant,
spin_order=spin_order,
phase_order=phase_order,
delta_t=1.0 / sample_rate,
f_lower=start_frequency,
amplitude_order=amplitude_order)
elif 'EccentricIMR' in approximant:
#{{{
# Legacy support
import sys
sys.path.append('/home/kuma/grav/kuma/src/Eccentric_IMR/Codes/Python/')
import EccentricIMR as Ecc
try:
mass1 = getattr(template_params, 'mass1')
mass2 = getattr(template_params, 'mass2')
except:
raise RuntimeError("template_params does not have mass1 or mass2!")
try:
ecc = getattr(template_params, 'alpha1')
if 'E0' in approximant: ecc = 0
anom = getattr(template_params, 'alpha2')
inc = getattr(template_params, 'inclination')
rtrans = getattr(template_params, 'alpha')
beta = 0
except:
raise RuntimeError(\
"template_params does not have alpha{,1,2} or inclination")
tol = 1.e-16
fmin = start_frequency
sample_rate = sample_rate
#
print(" Using phase order: %d" % phase_order, file=sys.stdout)
sys.stdout.flush()
hplus, hcross = Ecc.generate_eccentric_waveform(mass1, mass2,\
ecc, anom, inc, beta,\
tol,\
r_transition=rtrans,\
phase_order=phase_order,\
fmin=fmin,\
sample_rate=sample_rate,\
inspiral_only=False)
#}}}
elif 'EccentricInspiral' in approximant:
#{{{
# Legacy support
import sys
sys.path.append('/home/kuma/grav/kuma/src/Eccentric_IMR/Codes/Python/')
import EccentricIMR as Ecc
try:
mass1 = getattr(template_params, 'mass1')
mass2 = getattr(template_params, 'mass2')
except:
raise RuntimeError("template_params does not have mass1 or mass2!")
try:
ecc = getattr(template_params, 'alpha1')
if 'E0' in approximant: ecc = 0
anom = getattr(template_params, 'alpha2')
inc = getattr(template_params, 'inclination')
beta = getattr(template_params, 'alpha')
except:
raise RuntimeError(\
"template_params does not have alpha{,1,2} or inclination")
tol = 1.e-16
fmin = start_frequency
sample_rate = sample_rate
#
hplus, hcross = Ecc.generate_eccentric_waveform(mass1, mass2,\
ecc, anom, inc, beta,\
tol,\
phase_order=phase_order,\
fmin=fmin,\
sample_rate=sample_rate,\
inspiral_only=True)
#}}}
elif 'EccentricFD' in approximant:
#{{{
# Legacy support
import lalsimulation as ls
import lal
delta_f = sample_rate / length
try:
mass1 = getattr(template_params, 'mass1')
mass2 = getattr(template_params, 'mass2')
except:
raise RuntimeError("template_params does not have mass1 or mass2!")
try:
ecc = getattr(template_params, 'alpha1')
if 'E0' in approximant: ecc = 0
anom = getattr(template_params, 'alpha2')
inc = getattr(template_params, 'inclination')
except:
raise RuntimeError(\
"template_params does not have alpha{1,2} or inclination")
eccPar = ls.SimInspiralCreateTestGRParam("inclination_azimuth", inc)
ls.SimInspiralAddTestGRParam(eccPar, "e_min", ecc)
fmin = start_frequency
fmax = sample_rate / 2
#
thp, thc = ls.SimInspiralChooseFDWaveform(0, delta_f,\
mass1*lal.MSUN_SI, mass2*lal.MSUN_SI,\
0,0,0,0,0,0,\
fmin, fmax, 0, 1.e6 * lal.PC_SI,\
inc, 0, 0, None, eccPar, -1, 7, ls.EccentricFD)
hplus = FrequencySeries(thp.data.data[:],
delta_f=thp.deltaF,
epoch=thp.epoch)
hcross = FrequencySeries(thc.data.data[:],
delta_f=thc.deltaF,
epoch=thc.epoch)
#}}}
elif 'FromDataFile' in approximant:
#{{{
# Legacy support
if not os.path.exists(datafile):
raise IOError("File %s not found!" % datafile)
if verbose:
print("Reading from data file %s" % datafile)
# Figure out waveform parameters from filename
#q_value, M_value, w_value, _, _ = EA.get_q_m_e_pn_o_from_filename(datafile)
q_value, M_value, w_value = EA.get_q_m_e_from_filename(datafile)
# Read data, down-sample (assume data file is more finely sampled than
# needed, i.e. interpolation is NOT supported, nor will be)
data = np.loadtxt(datafile)
dt = data[1, 0] - data[0, 0]
delta_t = 1. / sample_rate
downsample_ratio = delta_t / dt
if not approx_equal(downsample_ratio, np.int(downsample_ratio)):
raise RuntimeError(
"Cannot handling resampling at a fractional factor = %e" %
downsample_ratio)
elif verbose:
print("Downsampling by a factor of %d" % int(downsample_ratio))
h_real = TimeSeries(data[::int(downsample_ratio), 1] / DYN_RANGE_FAC,
delta_t=delta_t)
h_imag = TimeSeries(data[::int(downsample_ratio), 2] / DYN_RANGE_FAC,
delta_t=delta_t)
if verbose:
print("max, min,len of h_real = ", max(h_real.data),
min(h_real.data), len(h_real.data))
# Compute Strain
tmplt_pars = template_params
wav = generate_detector_strain(tmplt_pars, h_real, h_imag)
wav = extend_waveform_TimeSeries(wav, filter_N)
# Return TimeSeries with (m1, m2, w_value)
m1, m2 = mtotal_eta_to_mass1_mass2(M_value,
q_value / (1. + q_value)**2)
htilde = make_frequency_series(wav)
htilde = extend_waveform_FrequencySeries(htilde, filter_n)
if verbose:
print("ISNAN(htilde from file) = ", np.any(np.isnan(htilde.data)))
return htilde, [m1, m2, w_value, dt]
#}}}
else:
raise IOError(".. APPROXIMANT %s not found.." % approximant)
##
hvec = hplus
htilde = make_frequency_series(hvec)
htilde = extend_waveform_FrequencySeries(htilde, filter_n)
#
print("type of hplus, hcross = ", type(hplus.data), type(hcross.data))
if any(isnan(hplus.data)) or any(isnan(hcross.data)):
print("..### %s hplus or hcross have NANS!!" % approximant)
#
if any(isinf(hplus.data)) or any(isinf(hcross.data)):
print("..### %s hplus or hcross have INFS!!" % approximant)
#
if any(isnan(htilde.data)):
print("..### %s Fourier transform htilde has NANS!!" % approximant)
#
if any(isinf(htilde.data)):
print("..### %s Fourier transform htilde has INFS!!" % approximant)
#
return htilde
spin1y=0.0,
spin2y=0.0,
spin1z=simulations.simulations[0]["spin1z"],
spin2z=simulations.simulations[0]["spin2z"],
inclination=inc,
f_lower=f_low_approx * min(masses) / mass,
delta_t=delta_t,
)
hplus_approx = wfutils.taper_timeseries(hplus_approx, "TAPER_STARTEND")
hcross_approx = wfutils.taper_timeseries(hcross_approx, "TAPER_STARTEND")
approx_freqs = wfutils.frequency_from_polarizations(hplus_approx, hcross_approx)
# elif approx == 'IMRPhenomPv2' or approx == 'IMRPhenomP':
elif approx in fd_approximants():
Hplus_approx, Hcross_approx = get_fd_waveform(
approximant=approx,
distance=distance,
mass1=mass1,
mass2=mass2,
spin1x=simulations.simulations[0]["spin1x"],
spin2x=simulations.simulations[0]["spin2x"],
spin1y=simulations.simulations[0]["spin1y"],
spin2y=simulations.simulations[0]["spin2y"],
spin1z=simulations.simulations[0]["spin1z"],
spin2z=simulations.simulations[0]["spin2z"],
inclination=inc,
f_lower=10, # f_low_approx * min(masses)/mass,
delta_f=delta_f,
parser.add_option("--match-file",
dest="out_file",
help="file to output match results",
metavar="FILE")
#PSD Settings
parser.add_option("--asd-file",
dest="asd_file",
help="two-column ASCII file containing ASD data",
metavar="FILE")
parser.add_option("--psd",
dest="psd",
help="Analytic PSD model from LALSimulation",
choices=pycbc.psd.get_lalsim_psd_list())
aprs = list(set(td_approximants() + fd_approximants()))
#Template Settings
parser.add_option(
"--template-file",
dest="bank_file",
help=
"SimInspiral or SnglInspiral XML file containing the template parameters.",
metavar="FILE")
parser.add_option("--template-approximant",
help="Template Approximant Name: " + str(aprs),
choices=aprs)
parser.add_option("--template-phase-order",
help="PN order to use for the phase",
default=-1,
type=int)
parser.add_option("--template-amplitude-order",
def get_waveform(wav, approximant, f_min, dt, N):
"""This function will generate the waveform corresponding to the point
taken as input"""
#{{{
m1 = wav.mass1
m2 = wav.mass2
s1x = wav.spin1x
s1y = wav.spin1y
s1z = wav.spin1z
s2x = wav.spin2x
s2y = wav.spin2y
s2z = wav.spin2z
ecc = wav.alpha
mean_per_ano = wav.alpha1
long_asc_nodes = wav.alpha2
coa_phase = wav.coa_phase
inc = wav.inclination
dist = wav.distance
df = 1. / (dt * N)
f_max = min(1. / (2. * dt), 0.15 / ((m1 + m2) * lal.MTSUN_SI))
if approximant in fd_approximants():
try:
hptild, hctild = get_fd_waveform(approximant=approximant,
mass1=m1,
mass2=m2,
spin1x=s1x,
spin1y=s1y,
spin1z=s1z,
spin2x=s2x,
spin2y=s2y,
spin2z=s2z,
eccentricity=ecc,
mean_per_ano=mean_per_ano,
long_asc_nodes=long_asc_nodes,
coa_phase=coa_phase,
inclination=inc,
distance=dist,
f_lower=f_min,
f_final=f_max,
delta_f=df)
except RuntimeError as re:
for c in dir(wav):
if "__" not in c and "get" not in c and "set" not in c and hasattr(
wav, c):
print(c, getattr(wav, c))
raise RuntimeError(re)
hptilde = FrequencySeries(hptild,
delta_f=df,
dtype=np.complex128,
copy=True)
hpref_padded = FrequencySeries(zeros(N / 2 + 1),
delta_f=df,
dtype=np.complex128,
copy=True)
hpref_padded[0:len(hptilde)] = hptilde
hctilde = FrequencySeries(hctild,
delta_f=df,
dtype=np.complex128,
copy=True)
hcref_padded = FrequencySeries(zeros(N / 2 + 1),
delta_f=df,
dtype=np.complex128,
copy=True)
hcref_padded[0:len(hctilde)] = hctilde
href_padded = generate_detector_strain(wav, hpref_padded, hcref_padded)
elif approximant in td_approximants():
#raise IOError("Time domain approximants not supported at the moment..")
try:
hp, hc = get_td_waveform(approximant=approximant,
mass1=m1,
mass2=m2,
spin1x=s1x,
spin1y=s1y,
spin1z=s1z,
spin2x=s2x,
spin2y=s2y,
spin2z=s2z,
eccentricity=ecc,
mean_per_ano=mean_per_ano,
long_asc_nodes=long_asc_nodes,
coa_phase=coa_phase,
inclination=inc,
distance=dist,
f_lower=f_min,
delta_t=dt)
except RuntimeError as re:
for c in dir(wav):
if "__" not in c and "get" not in c and "set" not in c and hasattr(
wav, c):
print(c, getattr(wav, c))
raise RuntimeError(re)
hpref_padded = TimeSeries(zeros(N),
delta_t=dt,
dtype=hp.dtype,
copy=True)
hpref_padded[:len(hp)] = hp
hcref_padded = TimeSeries(zeros(N),
delta_t=dt,
dtype=hc.dtype,
copy=True)
hcref_padded[:len(hc)] = hc
href_padded_td = generate_detector_strain(wav, hpref_padded,
hcref_padded)
href_padded = make_frequency_series(href_padded_td)
return href_padded
from pycbc.waveform import td_approximants, fd_approximants # List of td approximants that are available print(td_approximants()) # List of fd approximants that are currently available print(fd_approximants()) # Note that these functions only print what is available for your current # processing context. If a waveform is implemented in CUDA or OpenCL, it will # only be listed when running under a CUDA or OpenCL Scheme.
def calculate_faithfulness(m1, m2,
s1x=0, s1y=0, s1z=0,
s2x=0, s2y=0, s2z=0,
tc=0, phic=0,
ra=0, dec=0, polarization=0,
signal_approx='IMRPhenomD',
signal_file=None,
tmplt_approx='IMRPhenomC',
tmplt_file=None,
aligned_spin_tmplt_only=True,
non_spin_tmplt_only=False,
f_lower=15.0,
sample_rate=4096,
signal_duration=256,
psd_string='aLIGOZeroDetHighPower',
verbose=True,
debug=False):
"""
Calculates the match for a signal of given physical
parameters, as modelled by a given signal approximant, against
templates of another approximant.
This function allows turning off x,y components of
spin for templates.
IN PROGRESS: Adding facility to use "FromDataFile" waveforms
"""
# {{{
# 0) OPTION CHECKING
if aligned_spin_tmplt_only:
print(
"WARNING: Spin components parallel to L allowed, others set to 0 in templates.")
# 1) GENERATE FILTERING META-PARAMETERS
filter_N = signal_duration * sample_rate
filter_n = filter_N / 2 + 1
delta_t = 1./sample_rate
delta_f = 1./signal_duration
# LIGO Noise PSD
psd = from_string(psd_string, filter_n, delta_f, f_lower)
# 2) GENERATE THE TARGET SIGNAL
# Get the signal waveform first
if signal_approx in pywf.fd_approximants():
generator = pywfg.FDomainDetFrameGenerator(pywfg.FDomainCBCGenerator, 0,
variable_args=['mass1', 'mass2',
'spin1x', 'spin1y', 'spin1z',
'spin2x', 'spin2y', 'spin2z',
'coa_phase',
'tc', 'ra', 'dec', 'polarization'],
detectors=['H1'],
delta_f=delta_f, f_lower=f_lower,
approximant=signal_approx)
elif signal_approx in pywf.td_approximants():
generator = pywfg.TDomainDetFrameGenerator(pywfg.TDomainCBCGenerator, 0,
variable_args=['mass1', 'mass2',
'spin1x', 'spin1y', 'spin1z',
'spin2x', 'spin2y', 'spin2z',
'coa_phase',
'tc', 'ra', 'dec', 'polarization'],
detectors=['H1'],
delta_t=delta_t, f_lower=f_lower,
approximant=signal_approx)
elif 'FromDataFile' in signal_approx:
if os.path.getsize(signal_file) == 0:
raise RuntimeError(
" ERROR:...OOPS. Waveform file %s empty!!" % signal_file)
try:
_ = np.loadtxt(signal_file)
except:
raise RuntimeError(
" WARNING: FAILURE READING DATA FROM %s.." % signal_file)
waveform_params = lsctables.SimInspiral()
waveform_params.latitude = 0
waveform_params.longitude = 0
waveform_params.polarization = 0
waveform_params.spin1x = 0
waveform_params.spin1y = 0
waveform_params.spin1z = 0
waveform_params.spin2x = 0
waveform_params.spin2y = 0
waveform_params.spin2z = 0
# try:
if True:
if verbose:
print(".. generating signal waveform ")
signal_htilde, _params = get_waveform(signal_approx,
-1, -1, -1,
waveform_params,
f_lower,
sample_rate,
filter_N,
datafile=signal_file)
print(".. generated signal waveform ")
m1, m2, w_value, _ = _params
waveform_params.mass1 = m1
waveform_params.mass2 = m2
signal_h = make_frequency_series(signal_htilde)
signal_h = extend_waveform_FrequencySeries(signal_h, filter_n)
# except: raise IOError("Approximant %s not found.." % signal_approx)
else:
raise IOError("Signal Approximant %s not found.." % signal_approx)
if verbose:
print("..Generating signal with masses = %3f, %.3f, spin1 = (%.3f, %.3f, %.3f), and spin2 = (%.3f, %.3f, %.3f)" %
(m1, m2, s1x, s1y, s1z, s2x, s2y, s2z))
sys.stdout.flush()
if signal_approx in pywf.fd_approximants():
signal = generator.generate_from_args(m1, m2,
s1x, s1y, s1z,
s2x, s2y, s2z,
phic, tc, ra, dec, polarization)
# NOTE: SEOBNRv4 has extra high frequency content, it seems..
if 'SEOBNRv4_ROM' in signal_approx or 'SEOBNRv2_ROM' in signal_approx:
signal_h = extend_waveform_FrequencySeries(
signal['H1'], filter_n, force_fit=True)
else:
signal_h = extend_waveform_FrequencySeries(signal['H1'], filter_n)
elif signal_approx in pywf.td_approximants():
signal = generator.generate_from_args(m1, m2,
s1x, s1y, s1z,
s2x, s2y, s2z,
phic, tc, ra, dec, polarization)
signal_h = make_frequency_series(signal['H1'])
signal_h = extend_waveform_FrequencySeries(signal_h, filter_n)
elif 'FromDataFile' in signal_approx:
pass
else:
raise IOError("Signal Approximant %s not found.." % signal_approx)
# 3) GENERATE THE TARGET TEMPLATE
# Get the signal waveform first
if tmplt_approx in pywf.fd_approximants():
generator = pywfg.FDomainDetFrameGenerator(pywfg.FDomainCBCGenerator, 0,
variable_args=['mass1', 'mass2',
'spin1x', 'spin1y', 'spin1z',
'spin2x', 'spin2y', 'spin2z',
'coa_phase',
'tc', 'ra', 'dec', 'polarization'],
detectors=['H1'],
delta_f=delta_f, f_lower=f_lower,
approximant=tmplt_approx)
elif tmplt_approx in pywf.td_approximants():
generator = pywfg.TDomainDetFrameGenerator(pywfg.TDomainCBCGenerator, 0,
variable_args=['mass1', 'mass2',
'spin1x', 'spin1y', 'spin1z',
'spin2x', 'spin2y', 'spin2z',
'coa_phase',
'tc', 'ra', 'dec', 'polarization'],
detectors=['H1'],
delta_t=delta_t, f_lower=f_lower,
approximant=tmplt_approx)
elif 'FromDataFile' in tmplt_approx:
if os.path.getsize(tmplt_file) == 0:
raise RuntimeError(
" ERROR:...OOPS. Waveform file %s empty!!" % tmplt_file)
try:
_ = np.loadtxt(tmplt_file)
except:
raise RuntimeError(
" WARNING: FAILURE READING DATA FROM %s.." % tmplt_file)
waveform_params = lsctables.SimInspiral()
waveform_params.latitude = 0
waveform_params.longitude = 0
waveform_params.polarization = 0
waveform_params.spin1x = 0
waveform_params.spin1y = 0
waveform_params.spin1z = 0
waveform_params.spin2x = 0
waveform_params.spin2y = 0
waveform_params.spin2z = 0
# try:
if True:
if verbose:
print(".. generating signal waveform ")
tmplt_htilde, _params = get_waveform(tmplt_approx,
-1, -1, -1,
waveform_params,
f_lower,
1./delta_t,
filter_N,
datafile=tmplt_file)
print(".. generated signal waveform ")
m1, m2, w_value, _ = _params
waveform_params.mass1 = m1
waveform_params.mass2 = m2
tmplt_h = make_frequency_series(tmplt_htilde)
tmplt_h = extend_waveform_FrequencySeries(tmplt_h, filter_n)
# except: raise IOError("Approximant %s not found.." % tmplt_approx)
else:
raise IOError("Template Approximant %s not found.." % tmplt_approx)
#
if aligned_spin_tmplt_only:
_m1, _m2, _s1x, _s1y, _s1z, _s2x, _s2y, _s2z = m1, m2, 0, 0, s1z, 0, 0, s2z
elif non_spin_tmplt_only:
_m1, _m2, _s1x, _s1y, _s1z, _s2x, _s2y, _s2z = m1, m2, 0, 0, 0, 0, 0, 0
else:
_m1, _m2, _s1x, _s1y, _s1z, _s2x, _s2y, _s2z = m1, m2, s1x, s1y, s1z, s2x, s2y, s2z
#
# template = generator.generate_from_args(_m1, _m2, _s1x, _s1y, _s1z, _s2x, _s2y, _s2z,\
# phic, tc, ra, dec, polarization)
#
if verbose:
print(
"..Generating template with masses = %3f, %.3f, spin1 = (%.3f, %.3f, %.3f), and spin2 = (%.3f, %.3f, %.3f)" %
(_m1, _m2, _s1x, _s1y, _s1z, _s2x, _s2y, _s2z))
sys.stdout.flush()
if tmplt_approx in pywf.fd_approximants():
try:
template = generator.generate_from_args(_m1, _m2, _s1x, _s1y, _s1z, _s2x, _s2y, _s2z,
phic, tc, ra, dec, polarization)
except RuntimeError as rerr:
print("""FAILED TO GENERATE %s waveform for
masses = %.3f, %.3f
spins = (%.3f, %.3f, %.3f), (%.3f, %.3f, %.3f)
phic, tc, ra, dec, pol = (%.3f, %.3f, %.3f, %.3f, %.3f)""" %
(tmplt_approx, _m1, _m2, _s1x, _s1y, _s1z, _s2x, _s2y, _s2z,
phic, tc, ra, dec, polarization))
raise RuntimeError(rerr)
# NOTE: SEOBNRv4 has extra high frequency content, it seems..
if 'SEOBNRv4_ROM' in tmplt_approx or 'SEOBNRv2_ROM' in tmplt_approx:
template_h = extend_waveform_FrequencySeries(
template['H1'], filter_n, force_fit=True)
else:
template_h = extend_waveform_FrequencySeries(
template['H1'], filter_n)
elif tmplt_approx in pywf.td_approximants():
try:
template = generator.generate_from_args(_m1, _m2, _s1x, _s1y, _s1z, _s2x, _s2y, _s2z,
phic, tc, ra, dec, polarization)
except RuntimeError as rerr:
print("""FAILED TO GENERATE %s waveform for
masses = %.3f, %.3f
spins = (%.3f, %.3f, %.3f), (%.3f, %.3f, %.3f)
phic, tc, ra, dec, pol = (%.3f, %.3f, %.3f, %.3f, %.3f)""" %
(tmplt_approx, _m1, _m2, _s1x, _s1y, _s1z, _s2x, _s2y, _s2z,
phic, tc, ra, dec, polarization))
raise RuntimeError(rerr)
template_h = make_frequency_series(template['H1'])
template_h = extend_waveform_FrequencySeries(template_h, filter_n)
elif 'FromDataFile' in tmplt_approx:
pass
else:
raise IOError("Template Approximant %s not found.." % tmplt_approx)
# 4) COMPUTE MATCH
m, idx = match(signal_h, template_h, psd=psd, low_frequency_cutoff=f_lower)
if debug:
print(
"MATCH IS %.6f for parameters" % m, m1, m2, _s1x, _s1y, _s1z, _s2x, _s2y, _s2z)
sys.stderr.flush()
#
# 5) RETURN OPTIMIZED MATCH
return m, idx
def calculate_fitting_factor(m1, m2,
s1x=0, s1y=0, s1z=0,
s2x=0, s2y=0, s2z=0,
tc=0, phic=0,
ra=0, dec=0, polarization=0,
signal_approx='IMRPhenomD',
signal_file=None,
tmplt_approx='IMRPhenomC',
vary_masses_only=True,
vary_masses_and_aligned_spin_only=False,
chirp_mass_window=0.1,
effective_spin_window=0.5,
num_retries=4,
f_lower=15.0,
sample_rate=4096,
signal_duration=256,
psd_string='aLIGOZeroDetHighPower',
pso_swarm_size=500,
pso_omega=0.5,
pso_phip=0.5,
pso_phig=0.25,
pso_minfunc=1e-8,
verbose=True,
debug=False):
"""
Calculates the fitting factor for a signal of given physical
parameters, as modelled by a given signal approximant, against
templates of another approximant.
This function uses a particle swarm optimization to maximize
the overlaps between signal and templates. Algorithm parameters
are tunable, depending on how many dimensions we are optimizing
over.
IN PROGRESS: Adding facility to use "FromDataFile" waveforms
"""
# {{{
# 0) OPTION CHECKING
if vary_masses_only:
print("WARNING: Only component masses are allowed to be varied in templates. Setting the rest to signal values.")
if vary_masses_and_aligned_spin_only:
print("WARNING: Only component masses and spin components parallel to L allowed to be varied in templates. Setting the rest to signal values.")
if vary_masses_only and vary_masses_and_aligned_spin_only:
raise IOError(
"Inconsistent options: vary_masses_only and vary_masses_and_aligned_spin_only")
if (not vary_masses_only) and (not vary_masses_and_aligned_spin_only):
print("WARNING: All mass and spin components varied in templates. Sky parameters still fixed to signal values.")
# 1) GENERATE FILTERING META-PARAMETERS
signal_duration = int(signal_duration)
sample_rate = int(sample_rate)
filter_N = signal_duration * sample_rate
filter_n = filter_N / 2 + 1
delta_t = 1./sample_rate
delta_f = 1./signal_duration
if verbose:
print("signal_duration = %d, sample_rate = %d, filter_N = %d, filter_n = %d" % (
signal_duration, sample_rate, filter_N, filter_n))
print("deltaT = %f, deltaF = %f" % (delta_t, delta_f))
# LIGO Noise PSD
psd = from_string(psd_string, filter_n, delta_f, f_lower)
# 2) GENERATE THE TARGET SIGNAL
# PREPARATORY: Get the signal generator
if signal_approx in pywf.fd_approximants():
generator = pywfg.FDomainDetFrameGenerator(pywfg.FDomainCBCGenerator, 0,
variable_args=['mass1', 'mass2',
'spin1x', 'spin1y', 'spin1z',
'spin2x', 'spin2y', 'spin2z',
'coa_phase',
'tc', 'ra', 'dec', 'polarization'],
detectors=['H1'],
delta_f=delta_f, f_lower=f_lower,
approximant=signal_approx)
elif signal_approx in pywf.td_approximants():
generator = pywfg.TDomainDetFrameGenerator(pywfg.TDomainCBCGenerator, 0,
variable_args=['mass1', 'mass2',
'spin1x', 'spin1y', 'spin1z',
'spin2x', 'spin2y', 'spin2z',
'coa_phase',
'tc', 'ra', 'dec', 'polarization'],
detectors=['H1'],
delta_t=delta_t, f_lower=f_lower,
approximant=signal_approx)
elif 'FromDataFile' in signal_approx:
if os.path.getsize(signal_file) == 0:
raise RuntimeError(
" ERROR:...OOPS. Waveform file %s empty!!" % signal_file)
try:
_ = np.loadtxt(signal_file)
except:
raise RuntimeError(
" WARNING: FAILURE READING DATA FROM %s.." % signal_file)
waveform_params = lsctables.SimInspiral()
waveform_params.latitude = 0
waveform_params.longitude = 0
waveform_params.polarization = 0
waveform_params.spin1x = 0
waveform_params.spin1y = 0
waveform_params.spin1z = 0
waveform_params.spin2x = 0
waveform_params.spin2y = 0
waveform_params.spin2z = 0
# try:
if True:
if verbose:
print(".. generating signal waveform ")
signal_htilde, _params = get_waveform(signal_approx,
-1, -1, -1,
waveform_params,
f_lower,
sample_rate,
filter_N,
datafile=signal_file)
print(".. generated signal waveform ")
m1, m2, w_value, _ = _params
waveform_params.mass1 = m1
waveform_params.mass2 = m2
signal_h = make_frequency_series(signal_htilde)
signal_h = extend_waveform_FrequencySeries(signal_h, filter_n)
# except: raise IOError("Approximant %s not found.." % signal_approx)
else:
raise IOError("Approximant %s not found.." % signal_approx)
if verbose:
print(
"\nGenerating signal with masses = %3f, %.3f, spin1 = (%.3f, %.3f, %.3f), and spin2 = (%.3f, %.3f, %.3f)" %
(m1, m2, s1x, s1y, s1z, s2x, s2y, s2z))
sys.stdout.flush()
# Actually GENERATE THE SIGNAL
if signal_approx in pywf.fd_approximants():
signal = generator.generate_from_args(m1, m2, s1x, s1y, s1z, s2x, s2y, s2z,
phic, tc, ra, dec, polarization)
signal_h = extend_waveform_FrequencySeries(signal['H1'], filter_n)
elif signal_approx in pywf.td_approximants():
signal = generator.generate_from_args(m1, m2, s1x, s1y, s1z, s2x, s2y, s2z,
phic, tc, ra, dec, polarization)
signal_h = make_frequency_series(signal['H1'])
signal_h = extend_waveform_FrequencySeries(signal_h, filter_n)
elif 'FromDataFile' in signal_approx:
pass
else:
raise IOError("Approximant %s not found.." % signal_approx)
###
# NOW : Set up PSO calculation of the optimal overlap parameter set, i.e. \theta(FF)
###
# 3) INITIALIZE THE WAVEFORM GENERATOR FOR TEMPLATES
# We allow all intrinsic parameters to vary, and fix them to the signal
# values, in case only masses or only mass+aligned-spin components are
# requested to be varied. This fixing is done inside the objective function.
if tmplt_approx in pywf.fd_approximants():
generator_tmplt = pywfg.FDomainDetFrameGenerator(pywfg.FDomainCBCGenerator, 0,
variable_args=['mass1', 'mass2',
'spin1x', 'spin1y', 'spin1z',
'spin2x', 'spin2y', 'spin2z'
],
detectors=['H1'],
coa_phase=phic,
tc=tc, ra=ra, dec=dec, polarization=polarization,
delta_f=delta_f, f_lower=f_lower,
approximant=tmplt_approx)
elif tmplt_approx in pywf.td_approximants():
raise IOError(
"Time-domain templates not supported yet (TDomainDetFrameGenerator doesn't exist)")
generator_tmplt = pywfg.TDomainDetFrameGenerator(pywfg.TDomainCBCGenerator, 0,
variable_args=['mass1', 'mass2',
'spin1x', 'spin1y', 'spin1z',
'spin2x', 'spin2y', 'spin2z'
],
detectors=['H1'],
coa_phase=phic,
tc=tc, ra=ra, dec=dec, polarization=polarization,
delta_t=delta_t, f_lower=f_lower,
approximant=tmplt_approx)
elif 'FromDataFile' in tmplt_approx:
raise RuntimeError(
"Using **templates** from data files is not implemented yet")
else:
raise IOError("Approximant %s not found.." % tmplt_approx)
# 4) DEFINE AN OBJECTIVE FUNCTION FOR PSO TO MINIMIZE
def objective_function_fitting_factor(x, *args):
"""
This function is to be minimized if the fitting factor is to be found
"""
objective_function_fitting_factor.counter += 1
# 1) OBTAIN THE TEMPLATE PARAMETERS FROM X. ASSUME THAT ONLY
# THOSE ARE PASSED THAT ARE NEEDED BY THE GENERATOR
if len(x) == 2:
m1, m2 = x
if vary_masses_only:
_s1x = _s1y = _s1z = _s2x = _s2y = _s2z = 0
else:
_s1x, _s1y, _s1z = s1x, s1y, s1z
_s2x, _s2y, _s2z = s2x, s2y, s2z
elif len(x) == 4:
m1, m2, _s1z, _s2z = x
if vary_masses_and_aligned_spin_only:
_s1x = _s1y = _s2x = _s2y = 0
else:
_s1x, _s1y = s1x, s1y
_s2x, _s2y = s2x, s2y
elif len(x) == 8:
m1, m2, _s1x, _s1y, _s1z, _s2x, _s2y, _s2z = x
else:
raise IOError(
"No of vars %d not supported (should be 2 or 4 or 8)" % len(x))
# 2) CHECK FOR CONSISTENCY
if (_s1x**2 + _s1y**2 + _s1z**2) > s_max or (_s2x**2 + _s2y**2 + _s2z**2) > s_max:
return 1e99
# 2) ASSUME THAT
signal_h, tmplt_generator = args
tmplt = tmplt_generator.generate_from_args(
m1, m2, _s1x, _s1y, _s1z, _s2x, _s2y, _s2z)
tmplt_h = make_frequency_series(tmplt['H1'])
if debug:
print("IN FF Objective-> for parameters:", m1,
m2, _s1x, _s1y, _s1z, _s2x, _s2y, _s2z)
if debug:
print("IN FF Objective-> Length(tmplt) = %d, making it %d" %
(len(tmplt['H1']), filter_n))
# NOTE: SEOBNRv4 has extra high frequency content, it seems..
if 'SEOBNRv4_ROM' in tmplt_approx or 'SEOBNRv2_ROM' in tmplt_approx:
tmplt_h = extend_waveform_FrequencySeries(
tmplt_h, filter_n, force_fit=True)
else:
tmplt_h = extend_waveform_FrequencySeries(tmplt_h, filter_n)
# 3) COMPUTE MATCH
m, _ = match(signal_h, tmplt_h, psd=psd, low_frequency_cutoff=f_lower)
if debug:
print("MATCH IS %.6f for parameters:" %
m, m1, m2, _s1x, _s1y, _s1z, _s2x, _s2y, _s2z)
retval = np.log10(1. - m)
# We do not want PSO to go berserk, so we stop when FF = 0.999999
if retval <= -6.0:
retval = -6.0
return retval
objective_function_fitting_factor.counter = 0
# 5) DEFINE A CONSTRAINT FUNCTION FOR PSO TO RESPECT
def constraint_function_fitting_factor(x, *args):
"""
This function implements constraints on the optimization of fitting
factors:
1) spin magnitudes on both holes should be <= 1
"""
if len(x) == 2:
m1, m2 = x
s1x = s1y = s1z = s2x = s2y = s2z = 0
elif len(x) == 4:
m1, m2, s1z, s2z = x
s1x = s1y = s2x = s2y = 0
elif len(x) == 8:
m1, m2, s1x, s1y, s1z, s2x, s2y, s2z = x
# 1) Constraint on spin magnitudes
s1_mag = (s1x**2 + s1y**2 + s1z**2)**0.5
s2_mag = (s2x**2 + s2y**2 + s2z**2)**0.5
##
if (s1_mag > s_max) or (s2_mag > s_max):
return -1
# 2) Constraint on effective spin
s_eff = (s1z * m1 + s2z * m2) / (m1 + m2)
##
if (s_eff > s_eff_max) or (s_eff < s_eff_min):
return -1
# FINALLY) DEFAULT
return 1
# 6) FINALLY, CALL THE PSO TO COMPUTE THE FITTING FACTOR
# 6a) FIRST CONSTRUCT THE FIXED ARGUMENTS FOR THE PSO's OBJECTIVE FUNCTION
pso_args = (signal_h, generator_tmplt)
# 6b) NOW SET THE RANGE OF PARAMETERS TO BE PROBED
mt = m1 + m2 * 1.0
et = m1 * m2 / mt / mt
mc = mt * et**0.6
mc_min = mc * (1.0 - chirp_mass_window)
mc_max = mc * (1.0 + chirp_mass_window)
et_max = 0.25
et_min = 10. / 121. # Lets say we trust waveform models up to q = 10
m1_max, _ = pnutils.mchirp_eta_to_mass1_mass2(mc_max, et_min)
m1_min, _ = pnutils.mchirp_eta_to_mass1_mass2(mc_min, et_max)
_, m2_max = pnutils.mchirp_eta_to_mass1_mass2(mc_max, et_max)
_, m2_min = pnutils.mchirp_eta_to_mass1_mass2(mc_min, et_min)
s_min = -0.99
s_max = +0.99
s_eff = (s1z * m1 + s2z * m2) / (m1 + m2)
s_eff_min = s_eff - effective_spin_window
s_eff_max = s_eff + effective_spin_window
if verbose:
print(m1, m2, mt, et, mc, mc_min, mc_max, et_min,
et_max, m1_min, m1_max, m2_min, m2_max)
if vary_masses_only:
low_lim = [m1_min, m2_min]
high_lim = [m1_max, m2_max]
elif vary_masses_and_aligned_spin_only:
low_lim = [m1_min, m2_min, s_min, s_min]
high_lim = [m1_max, m2_max, s_max, s_max]
else:
low_lim = [m1_min, m2_min, s_min, s_min, s_min, s_min, s_min, s_min]
high_lim = [m1_max, m2_max, s_max, s_max, s_max, s_max, s_max, s_max]
#
if verbose:
print("\nSearching within limits:\n", low_lim, " and \n", high_lim)
print("\nCalculating overlap now..")
sys.stdout.flush()
olap, idx = calculate_faithfulness(m1, m2, s1x, s1y, s1z, s2x, s2y, s2z,
tc=tc, phic=phic,
ra=ra, dec=dec,
polarization=polarization,
signal_approx=signal_approx,
signal_file=signal_file,
tmplt_approx=tmplt_approx,
tmplt_file=None,
aligned_spin_tmplt_only=vary_masses_and_aligned_spin_only,
non_spin_tmplt_only=vary_masses_only,
f_lower=f_lower, sample_rate=sample_rate,
signal_duration=signal_duration,
verbose=verbose, debug=debug)
#
if verbose:
print("Overlap with aligned_spin_tmplt_only = ", vary_masses_and_aligned_spin_only,
" and non_spin_tmplt_only = ", vary_masses_only, ": ", olap, np.log10(
1. - olap))
sys.stdout.flush()
#
idx = 1
ff = 0.0
while ff < olap:
if idx and idx % 2 == 0:
pso_minfunc *= 0.1
pso_phig *= 1.1
if idx > num_retries:
print(
"WARNING: Failed to improve on overlap in %d iterations. Set ff = olap now" % num_retries)
ff = olap
break
if verbose:
print("\nTry %d to compute fitting factor" % idx)
sys.stdout.flush()
params, ff = pso(objective_function_fitting_factor,
low_lim, high_lim,
f_ieqcons=constraint_function_fitting_factor,
args=pso_args,
swarmsize=pso_swarm_size,
omega=pso_omega,
phip=pso_phip,
phig=pso_phig,
minfunc=pso_minfunc,
maxiter=500,
debug=verbose)
# Restore fitting factor from 1-ff
ff = 1.0 - 10**ff
if verbose:
print("\nLoop will continue till %.12f < %.12f" % (ff, olap))
sys.stdout.flush()
idx += 1
if verbose:
print("optimization took %d objective func evals" %
objective_function_fitting_factor.counter)
sys.stdout.flush()
#
# 7) RETURN OPTIMIZED PARAMETERS
return [params, olap, ff]
parser = optparse.OptionParser()
parser.add_option('--scheme','-s', action='callback', type = 'choice',
choices = ('cpu','cuda'),
default = 'cpu', dest = 'scheme', callback = _check_scheme_cpu,
help = optparse.SUPPRESS_HELP)
parser.add_option('--device-num','-d', action='store', type = 'int',
dest = 'devicenum', default=0,
help = optparse.SUPPRESS_HELP)
parser.add_option('--show-plots', action='store_true',
help = 'show the plots generated in this test suite')
parser.add_option('--save-plots', action='store_true',
help = 'save the plots generated in this test suite')
parser.add_option('--approximant', type = 'choice', choices = td_approximants() + fd_approximants(),
help = "Choices are %s" % str(td_approximants() + fd_approximants()))
parser.add_option('--mass1', type = float, default=10, help = "[default: %default]")
parser.add_option('--mass2', type = float, default=10, help = "[default: %default]")
parser.add_option('--spin1x', type = float, default=0, help = "[default: %default]")
parser.add_option('--spin1y', type = float, default=0, help = "[default: %default]")
parser.add_option('--spin1z', type = float, default=0, help = "[default: %default]")
parser.add_option('--spin2x', type = float, default=0, help = "[default: %default]")
parser.add_option('--spin2y', type = float, default=0, help = "[default: %default]")
parser.add_option('--spin2z', type = float, default=0, help = "[default: %default]")
parser.add_option('--lambda1', type = float, default=0, help = "[default: %default]")
parser.add_option('--lambda2', type = float, default=0, help = "[default: %default]")
parser.add_option('--coa-phase', type = float, default=0, help = "[default: %default]")
parser.add_option('--inclination', type = float, default=0, help = "[default: %default]")
def generate_intrinsic_waveform(
sample: Union[np.record, Dict[str, float]],
static_args: Dict[str, Union[str, float]],
spins: bool=True,
spins_aligned: bool=False,
# inclination: bool=True,
downcast: bool=True,
as_pycbc: bool=False,
) -> Union[Tuple[TimeSeries], Tuple[FrequencySeries]]:
"""Function generates a waveform in either time or frequency domain using PyCBC methods.
Arguments:
intrinsic: Union[np.record, Dict[str, float]]
A one dimensional vector (or dictionary of scalars) of intrinsic parameters that parameterise a given waveform.
We require sample to be one row in a because we want to process one waveform at a time,
but we want to be able to use the PyCBC prior distribution package which outputs numpy.records.
static_args: Dict[str, Union[str, float]]
A dictionary of type-casted (from str to floats or str) arguments loaded from an .ini file.
We expect keys in this dictionary to specify the approximant, domain, frequency bands, etc.
inclination: bool
spins: bool
spins_aligned: bool
downcast: bool
If True, downcast from double precision to full precision.
E.g. np.complex124 > np.complex64 for frequency, np.float64 > np.float32 for time.
Returns:
(hp, hc)
A tuple of the plus and cross polarizations as pycbc Array types
depending on the specified waveform domain (i.e. time or frequency).
"""
# type checking inputs
if isinstance(sample, np.record):
assert sample.shape == (), "input array be a 1 dimensional record array. (PyCBC compatibility)"
for param in ('mass_1', 'mass_2', 'phase'):
if isinstance(sample, np.record):
assert param in sample.dtype.names, f"{param} not provided in sample."
if isinstance(sample, dict):
assert param in sample.keys(), f"{param} not provided in sample."
for arg in ('approximant', 'domain','f_lower', 'f_final', 'f_ref'):
assert arg in static_args, f"{arg} not provided in static_args."
if arg == 'domain':
assert static_args['domain'] in ('time', 'frequency'), (
f"{static_args['domain']} is not a valid domain."
)
# reference distance - we are generating intrinsic parameters and we scale distance later
distance = static_args.get('distance', 1000) # function default is 1, we use 1000 as ref dist
# determine parameters conditional on spin and inclination of CBC
if spins:
if spins_aligned:
iota = sample['theta_jn'] # we don't want to overwrite theta_jn if spins not aligned
spin_1x, spin_1y, spin_1z = 0., 0., sample['chi_1']
spin_2x, spin_2y, spin_2z = 0., 0., sample['chi_2']
else:
# convert from event frame to radiation frame
iota, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z = source_frame_to_radiation(
sample['mass_1'], sample['mass_2'], sample['phase'], sample['theta_jn'], sample['phi_jl'],
sample['tilt_1'], sample['tilt_2'], sample['phi_12'], sample['a_1'], sample['a_2'], static_args['f_ref'],
)
else:
iota = sample['theta_jn']
spin_1x, spin_1y, spin_1z = 0., 0., 0.
spin_2x, spin_2y, spin_2z = 0., 0., 0.
if static_args['domain'] in ('time',):
# generate time domain waveform
assert 'delta_t' in static_args, "delta_t not provided in static_args."
assert static_args['approximant'] in td_approximants(), (
f"{static_args['approximant']} is not a valid time domain waveform"
)
# TO DO: Handle variable length td_waveform generation.
# ValueError: Time series does not contain a time as early as -8.
raise NotImplementedError('time domain waveforms not yet implemented.')
# Make sure f_min is low enough
# if static_args['waveform_length'] > get_waveform_filter_length_in_time(
# mass1=sample['mass_1'], mass2=sample['mass_2'],
# spin1x=spin_1x, spin2x=spin_2x,
# spin1y=spin_1y, spin2y=spin_2y,
# spin1z=spin_1z, spin2z=spin_2z,
# inclination=iota,
# f_lower=static_args['f_lower'],
# f_ref=static_args['f_ref'],
# approximant=static_args['approximant'],
# distance=distance,
# ):
# print('Warning: f_min not low enough for given waveform duration')
# get plus polarisation (hp) and cross polarisation (hc) as time domain waveforms
hp, hc = get_td_waveform(
mass1=sample['mass_1'], mass2=sample['mass_2'],
spin1x=spin_1x, spin2x=spin_2x,
spin1y=spin_1y, spin2y=spin_2y,
spin1z=spin_1z, spin2z=spin_2z,
coa_phase=sample['phase'],
inclination=iota, # "Check this!" - Stephen Green
delta_t=static_args['delta_t'],
f_lower=static_args['f_lower'],
f_ref=static_args['f_ref'],
approximant=static_args['approximant'],
distance=distance,
)
# Apply the fade-on filter to them - should be timeseries only?
# if static_arguments['domain'] == 'time':
# h_plus = fade_on(h_plus, alpha=static_arguments['tukey_alpha'])
# h_cross = fade_on(h_cross, alpha=static_arguments['tukey_alpha'])
# waveform coalesces at t=0, but t=0 is at end of array
# add to start_time s.t. (t=l-ength, t=0) --> (t=0, t=length)
hp = hp.time_slice(-int(static_args['waveform_length']), 0.0)
hc = hc.time_slice(-int(static_args['waveform_length']), 0.0)
hp.start_time += static_args['waveform_length']
hc.start_time += static_args['waveform_length']
# Resize the simulated waveform to the specified length ??
# need to be careful here
# hp.resize(static_args['original_sampling_rate'])
# hc.resize(static_args['original_sampling_rate'])
if downcast:
hp = hp.astype(np.float32)
hc = hc.astype(np.float32)
elif static_args['domain'] in ('frequency',):
# generate frequency domain waveform
assert 'delta_t' in static_args, "delta_t not provided in static_args."
assert static_args['approximant'] in fd_approximants(), (
f"{static_args['approximant']} is not a valid frequency domain waveform"
)
hp, hc = get_fd_waveform(
mass1=sample['mass_1'], mass2=sample['mass_2'],
spin1x=spin_1x, spin2x=spin_2x,
spin1y=spin_1y, spin2y=spin_2y,
spin1z=spin_1z, spin2z=spin_2z,
coa_phase=sample['phase'],
inclination=iota, # "Check this!" - Stephen Green
delta_f=static_args['delta_f'],
f_lower=static_args['f_lower'],
f_final=static_args['f_final'],
f_ref=static_args['f_ref'],
approximant=static_args['approximant'],
distance=distance,
)
# time shift - should we do this when we create or project the waveform?
hp = hp.cyclic_time_shift(static_args['seconds_before_event'])
hc = hc.cyclic_time_shift(static_args['seconds_before_event'])
hp.start_time += static_args['seconds_before_event']
hc.start_time += static_args['seconds_before_event']
if downcast:
hp = hp.astype(np.complex64)
hc = hc.astype(np.complex64)
if as_pycbc:
return hp, hc
return hp.data, hc.data
return htilde
###############################################################################
#File output Settings
parser = OptionParser()
parser.add_option("--match-file", dest="out_file", help="file to output match results", metavar="FILE")
#PSD Settings
parser.add_option("--asd-file", dest="asd_file", help="two-column ASCII file containing ASD data", metavar="FILE")
parser.add_option("--psd", dest="psd", help="Analytic PSD model from LALSimulation", choices=pycbc.psd.get_lalsim_psd_list())
aprs = list(set(td_approximants() + fd_approximants()))
#Template Settings
parser.add_option("--template-file", dest="bank_file", help="SimInspiral or SnglInspiral XML file containing the template parameters.", metavar="FILE")
parser.add_option("--template-approximant",help="Template Approximant Name: " + str(aprs), choices = aprs)
parser.add_option("--template-phase-order",help="PN order to use for the phase",default=-1,type=int)
parser.add_option("--template-amplitude-order",help="PN order to use for the amplitude",default=-1,type=int)
parser.add_option("--template-start-frequency",help="Starting frequency for injections",type=float)
parser.add_option("--template-sample-rate",help="Starting frequency for injections",type=float)
#Signal Settings
parser.add_option("--signal-file", dest="sim_file", help="SimInspiral or SnglInspiral XML file containing the signal parameters.", metavar="FILE")
parser.add_option("--signal-approximant",help="Signal Approximant Name: " + str(aprs), choices = aprs)
parser.add_option("--signal-phase-order",help="PN order to use for the phase",default=-1,type=int)
parser.add_option("--signal-amplitude-order",help="PN order to use for the amplitude",default=-1,type=int)
parser.add_option("--signal-start-frequency",help="Starting frequency for templates",type=float)
parser.add_option("--signal-sample-rate",help="Starting frequency for templates",type=float)
from pycbc.waveform import td_approximants, fd_approximants # List of td approximants that are available print td_approximants() # List of fd approximants that are currently available print fd_approximants() # Note that these functions only print what is available for your current # processing context. If a waveform is implemented in CUDA or OpenCL, it will # only be listed when running under a CUDA or OpenCL Scheme.
parser = optparse.OptionParser()
parser.add_option('--scheme','-s', action='callback', type = 'choice',
choices = ('cpu','cuda'),
default = 'cpu', dest = 'scheme', callback = _check_scheme_cpu,
help = optparse.SUPPRESS_HELP)
parser.add_option('--device-num','-d', action='store', type = 'int',
dest = 'devicenum', default=0,
help = optparse.SUPPRESS_HELP)
parser.add_option('--show-plots', action='store_true',
help = 'show the plots generated in this test suite')
parser.add_option('--save-plots', action='store_true',
help = 'save the plots generated in this test suite')
parser.add_option('--approximant', type = 'choice', choices = td_approximants() + fd_approximants(),
help = "Choices are %s" % str(td_approximants() + fd_approximants()))
parser.add_option('--mass1', type = float, default=10, help = "[default: %default]")
parser.add_option('--mass2', type = float, default=9, help = "[default: %default]")
parser.add_option('--spin1x', type = float, default=0, help = "[default: %default]")
parser.add_option('--spin1y', type = float, default=0, help = "[default: %default]")
parser.add_option('--spin1z', type = float, default=0, help = "[default: %default]")
parser.add_option('--spin2x', type = float, default=0, help = "[default: %default]")
parser.add_option('--spin2y', type = float, default=0, help = "[default: %default]")
parser.add_option('--spin2z', type = float, default=0, help = "[default: %default]")
parser.add_option('--lambda1', type = float, default=0, help = "[default: %default]")
parser.add_option('--lambda2', type = float, default=0, help = "[default: %default]")
parser.add_option('--coa-phase', type = float, default=0, help = "[default: %default]")
parser.add_option('--inclination', type = float, default=0, help = "[default: %default]")
pn24 = figure(title='Phase',
x_axis_label='freq(Hz)',
y_axis_label='rad',
plot_width=500,
plot_height=400)
pn24.line(x='freq', y='phase', source=sourcep2, color='red', line_width=3)
pn24.toolbar.logo = None
q_sliderFD = Slider(start=1, end=10, value=1, step=.5, title="Mass ratio (q)")
e_sliderFD = Slider(start=0.,
end=0.9,
value=0,
step=.05,
title="Eccentricity (e)")
model_selectFD = Select(title="FD Models", options=fd_approximants())
def update_slider(attrname, old, new):
# Get the current slider values
q = q_sliderFD.value
e = e_sliderFD.value
approximant = model_selectFD.value
freq, hp_real, hc_real, hp_imag, hc_imag, amp, phase = generate_analytic_waveform(
mass_rat=q, eccentricity=e, approximant=approximant)
sourcep2.data = {
'hp_real': hp_real,
'hc_real': hc_real,
'hp_imag': hp_imag,
'hc_imag': hc_imag,
'amp': amp,
