def sinegaussian_example(axes1, axes2, e, pol):
axes1.grid(True)
axes2.grid(True)
hp, hc = lalsimulation.SimBurstSineGaussian(8.89, 250., 1., e, pol,
1. / 16384)
print("measured hrss = %.17g" % lalsimulation.MeasureHrss(hp, hc))
t = float(hp.epoch) + numpy.arange(0., len(hp.data.data)) * hp.deltaT
axes1.plot(t, hp.data.data, label=r"$h_{+}$")
t = float(hc.epoch) + numpy.arange(0., len(hc.data.data)) * hc.deltaT
axes1.plot(t, hc.data.data, label=r"$h_{\times}$")
axes1.set_ylim((-15, +15))
axes1.set_xlabel(r"Time (seconds)")
axes1.set_ylabel(r"Strain")
axes1.set_title(
r"$f_{0} = 250\,\mathrm{Hz}$, $Q = 8.89$, $h_{\mathrm{rss}} = 1$, $\epsilon = %g$, $\phi = %g \pi$"
% (e, pol / math.pi))
axes1.legend()
axes2.plot(hc.data.data, hp.data.data, color="k")
axes2.set_xlim((-15, +15))
axes2.set_ylim((-15, +15))
axes2.set_xlabel(r"$h_{\times}$")
axes2.set_ylabel(r"$h_{+}$")
axes2.set_title(
r"$f_{0} = 250\,\mathrm{Hz}$, $Q = 8.89$, $h_{\mathrm{rss}} = 1$, $\epsilon = %g$, $\phi = %g \pi$"
% (e, pol / math.pi))
axes2.set_aspect(1., adjustable="box")
def _lalsim_sgburst_waveform(**p):
hp, hc = lalsimulation.SimBurstSineGaussian(float(p['q']),
float(p['frequency']),
float(p['hrss']),
float(p['eccentricity']),
float(p['polarization']),
float(p['delta_t']))
hp = TimeSeries(hp.data.data[:], delta_t=hp.deltaT, epoch=hp.epoch)
hc = TimeSeries(hc.data.data[:], delta_t=hc.deltaT, epoch=hc.epoch)
return hp, hc
def SG_template(frequency,
quality,
delta_t=1. / 16384,
epoch=0.0,
datalen=16384):
"""
Return a pycbc timeseries object with a sine-Gaussian with hrss=1,
ellipticity=1, polar angle=0
"""
hp, _ = lalsim.SimBurstSineGaussian(quality, frequency, 1.0 / np.sqrt(2),
1.0, 0, delta_t)
tmparr = np.zeros(datalen)
tmparr[:hp.data.length] = hp.data.data[:]
return pycbc.types.TimeSeries(tmparr, delta_t=delta_t, epoch=epoch)
def apply(self, strain, detector_name, f_lower=None, distance_scale=1):
"""Add injections (as seen by a particular detector) to a time series.
Parameters
----------
strain : TimeSeries
Time series to inject signals into, of type float32 or float64.
detector_name : string
Name of the detector used for projecting injections.
f_lower : {None, float}, optional
Low-frequency cutoff for injected signals. If None, use value
provided by each injection.
distance_scale: {1, foat}, optional
Factor to scale the distance of an injection with. The default is
no scaling.
Returns
-------
None
Raises
------
TypeError
For invalid types of `strain`.
"""
if strain.dtype not in (float32, float64):
raise TypeError("Strain dtype must be float32 or float64, not " \
+ str(strain.dtype))
lalstrain = strain.lal()
detector = Detector(detector_name)
earth_travel_time = lal.REARTH_SI / lal.C_SI
t0 = float(strain.start_time) - earth_travel_time
t1 = float(strain.end_time) + earth_travel_time
# pick lalsimulation injection function
add_injection = injection_func_map[strain.dtype]
for inj in self.table:
# roughly estimate if the injection may overlap with the segment
end_time = inj.get_time_geocent()
#CHECK: This is a hack (10.0s); replace with an accurate estimate
inj_length = 10.0
eccentricity = 0.0
polarization = 0.0
start_time = end_time - 2 * inj_length
if end_time < t0 or start_time > t1:
continue
# compute the waveform time series
hp, hc = sim.SimBurstSineGaussian(float(inj.q),
float(inj.frequency),
float(inj.hrss),
float(eccentricity),
float(polarization),
float(strain.delta_t))
hp = TimeSeries(hp.data.data[:], delta_t=hp.deltaT, epoch=hp.epoch)
hc = TimeSeries(hc.data.data[:], delta_t=hc.deltaT, epoch=hc.epoch)
hp._epoch += float(end_time)
hc._epoch += float(end_time)
if float(hp.start_time) > t1:
continue
# compute the detector response, taper it if requested
# and add it to the strain
strain = wfutils.taper_timeseries(strain, inj.taper)
signal_lal = hp.astype(strain.dtype).lal()
add_injection(lalstrain, signal_lal, None)
strain.data[:] = lalstrain.data.data[:]
def damped_chirp_tmplt(det_data, int_params, ext_params):
"""
Build a template for the detector in det_data from the intrinsic and
extrinsic parameteres in int_params and ext_params
"""
#
# Compute polarisations for damped chirp
#
# _, hp = damped_chirp(int_params.tmplt_len,
# int_params.Amp, int_params.f0, int_params.tau, int_params.df)
#
# _, hc = damped_chirp(int_params.tmplt_len,
# int_params.Amp, int_params.f0, int_params.tau, int_params.df,
# phi0=90.0)
#
# # Get the epoch for the start of the time series
epoch = ext_params.geocent_peak_time # - \
# #np.argmax(hp)*det_data.td_response.delta_t
# # XXX: why don't we need to subtract this bit...?
#
#
# # --- Put the polarisations into LAL TimeSeries
Q = 2.0 * np.pi * int_params.tau * int_params.f0
hp, hc = lalsim.SimBurstSineGaussian(Q, int_params.f0, int_params.Amp, 0,
0, 1.0 / 16384)
# zero-out...
hp.data.data[0:hp.data.length / 2] = 0.0
hc.data.data[0:hp.data.length / 2] = 0.0
hplus = lal.CreateREAL8TimeSeries('hplus', epoch, 0,
det_data.td_noise.delta_t,
lal.StrainUnit, hp.data.length)
hplus.data.data = np.copy(hp.data.data)
del hp
hcross = lal.CreateREAL8TimeSeries('hcross', epoch, 0,
det_data.td_noise.delta_t,
lal.StrainUnit, hc.data.length)
hcross.data.data = np.copy(hc.data.data)
del hc
#
# # --- Put the polarisations into LAL TimeSeries
# hplus = lal.CreateREAL8TimeSeries('hplus', epoch, 0,
# det_data.td_noise.delta_t, lal.StrainUnit, len(hp))
# hplus.data.data=np.copy(hp)
# del hp
#
# hcross = lal.CreateREAL8TimeSeries('hcross', epoch, 0,
# det_data.td_noise.delta_t, lal.StrainUnit, len(hc))
# hcross.data.data=np.copy(hc)
# del hc
#
# Project polarisations down to detector
#
tmplt = lalsim.SimDetectorStrainREAL8TimeSeries(hplus, hcross,
ext_params.ra,
ext_params.dec,
ext_params.polarization,
det_data.det_site)
del hplus, hcross
# Scale for distance (waveforms extracted at 20 Mpc)
tmplt.data.data *= 20.0 / ext_params.distance
#
# Finally make this the same size as the data (useful for fitting)
#
#lal.ResizeREAL8TimeSeries(tmplt, 0, len(det_data.td_response.data))
no_noise = lal.CreateREAL8TimeSeries(
'blah', det_data.td_noise.start_time, 0, det_data.td_noise.delta_t,
lal.StrainUnit,
int(det_data.td_noise.duration / det_data.td_noise.delta_t))
no_noise.data.data = np.zeros(
int(det_data.td_noise.duration / det_data.td_noise.delta_t))
tmplt = lal.AddREAL8TimeSeries(no_noise, tmplt)
return pycbc.types.timeseries.TimeSeries(\
initial_array=np.copy(tmplt.data.data), delta_t=tmplt.deltaT,
epoch=tmplt.epoch)
def reconstructed_SineGaussianF(posterior, waveform, flow=1000, fupp=4096,
nrec=100):
"""
return the reconstructed F-domain sine-Gaussians from the posterior samples
in posterior, as well as the max-posterior reconstruction and the matches
with the target waveform
"""
wlen=16384
# Get a zero-padded version of the target waveform
htarget=np.zeros(wlen)
htarget[0:len(waveform.hplus)]=waveform.hplus.data
htarget=pycbc.types.TimeSeries(htarget, delta_t = waveform.hplus.delta_t)
# Normalise so that the target has hrss=1
#hrssTarget = pycbc.filter.sigma(htarget, low_frequency_cutoff=flow,
# high_frequency_cutoff=fupp)
#htarget.data /= hrssTarget
# Get frequency series of target waveform
H_target = htarget.to_frequencyseries()
# Make psd for matches
flen = len(H_target)
delta_f = np.diff(H_target.sample_frequencies)[0]
psd = aLIGOZeroDetHighPower(flen, H_target.delta_f, low_freq_cutoff=flow)
# -----------
# MAP waveform
# XXX: Time-domain is a little easier, since we don't have to figure out
# which frequencies to populate in a pycbc object
hp, _ = lalsim.SimBurstSineGaussian(posterior.maxP[1]['quality'],
posterior.maxP[1]['frequency'], posterior.maxP[1]['hrss'], 0.0, 0.0,
waveform.hplus.delta_t)
#hp, _ = lalsim.SimBurstSineGaussian(posterior.maxP[1]['quality'],
# posterior.maxP[1]['frequency'], 1.0, 0.0, 0.0,
# waveform.hplus.delta_t)
# zero-pad
h_MAP = np.zeros(wlen)
# populate
h_MAP[:hp.data.length]=hp.data.data
# pycbc objects
h_MAP_ts = pycbc.types.TimeSeries(h_MAP,waveform.hplus.delta_t)
H_MAP = h_MAP_ts.to_frequencyseries()
MAP_match = pycbc.filter.match(H_target, H_MAP, low_frequency_cutoff=flow,
high_frequency_cutoff=fupp)[0]
# -------------------------
# Waveforms for all samples
# Pre-allocate:
#nrec=500
if len(posterior['frequency'].samples)>nrec:
decidx = np.random.randint(0, len(posterior['frequency'].samples),
nrec)
else:
decidx = xrange(nrec)
reconstructions = np.zeros(shape=(nrec, len(H_target)), dtype=complex)
matches = np.zeros(nrec)
# All samples!
for idx in xrange(nrec):
# let's just use hplus for now...
hp, _ = lalsim.SimBurstSineGaussian(
np.squeeze(posterior['quality'].samples)[idx],
np.squeeze(posterior['frequency'].samples)[idx],
np.squeeze(posterior['hrss'].samples)[idx], 0.0, 0.0,
waveform.hplus.delta_t)
#hp, _ = lalsim.SimBurstSineGaussian(
# np.squeeze(posterior['quality'].samples)[idx],
# np.squeeze(posterior['frequency'].samples)[idx],
# 1.0, 0.0, 0.0,
# waveform.hplus.delta_t)
# zero pad
hcurrent = np.zeros(wlen)
# populate
hcurrent[:hp.data.length] = hp.data.data
# pycbc object
hcurrent_ts = pycbc.types.TimeSeries(hcurrent, delta_t=hp.deltaT)
# populate array of all reconstructions
reconstructions[idx, :] = hcurrent_ts.to_frequencyseries().data
# compute match for this sample
matches[idx] = pycbc.filter.match(H_target,
hcurrent_ts.to_frequencyseries(), low_frequency_cutoff=flow,
high_frequency_cutoff=fupp)[0]
# -----------
reconstruction = {}
reconstruction['FrequencyAxis'] = H_MAP.sample_frequencies
reconstruction['TargetSpectrum'] = H_target
reconstruction['MAPSpectrum'] = H_MAP
reconstruction['MAPMatch'] = MAP_match
reconstruction['SampledReconstructions'] = reconstructions
reconstruction['SampledMatches'] = matches
return reconstruction
