def __init__(self,
initial_array,
delta_f=None,
epoch="",
dtype=None,
copy=True):
if len(initial_array) < 1:
raise ValueError('initial_array must contain at least one sample.')
if delta_f is None:
try:
delta_f = initial_array.delta_f
except AttributeError:
raise TypeError(
'must provide either an initial_array with a delta_f attribute, or a value for delta_f'
)
if not delta_f > 0:
raise ValueError('delta_f must be a positive number')
# We gave a nonsensical default value to epoch so we can test if it's been set.
# If the user passes in an initial_array that has an 'epoch' attribute and doesn't
# pass in a value of epoch, then our new object's epoch comes from initial_array.
# But if the user passed in a value---even 'None'---that will take precedence over
# anything set in initial_array. Finally, if the user passes in something without
# an epoch attribute *and* doesn't pass in a value of epoch, it becomes 'None'
if not isinstance(epoch, _lal.LIGOTimeGPS):
if epoch == "":
if isinstance(initial_array, FrequencySeries):
epoch = initial_array._epoch
else:
epoch = _lal.LIGOTimeGPS(0)
elif epoch is not None:
try:
epoch = _lal.LIGOTimeGPS(epoch)
except:
raise TypeError(
'epoch must be either None or a lal.LIGOTimeGPS')
Array.__init__(self, initial_array, dtype=dtype, copy=copy)
self._delta_f = delta_f
self._epoch = epoch
def utc_midnight(gps): """ Truncate a LIGOTimeGPS to UTC midnight. """ # convert to UTC (as list so we can edit it) tm = list(lal.GPSToUTC(int(gps))) # truncate to midnight tm[3] = 0 # hours tm[4] = 0 # minutes tm[5] = 0 # seconds # convert back to LIGOTimeGPS return lal.LIGOTimeGPS(lal.UTCToGPS(tuple(tm)))
def __init__(self,
initial_array,
delta_t,
epoch=None,
dtype=None,
copy=True):
"""initial_array: array containing sampled data.
delta_t: time between consecutive samples in seconds.
epoch: time series start time in seconds. Must be a lal.LIGOTimeGPS object.
"""
if len(initial_array) < 1:
raise ValueError('initial_array must contain at least one sample.')
if not delta_t > 0:
raise ValueError('delta_t must be a positive number')
if epoch is not None and not isinstance(epoch, _lal.LIGOTimeGPS):
raise TypeError('epoch must be either None or a lal.LIGOTimeGPS')
if epoch is None:
epoch = _lal.LIGOTimeGPS(0, 0)
else:
epoch = _lal.LIGOTimeGPS(epoch)
Array.__init__(self, initial_array, dtype=dtype, copy=copy)
self._delta_t = delta_t
self._epoch = epoch
def to_lal_frequencyseries(self):
"""
Output the frequency series strain data as a LAL FrequencySeries object.
"""
laldata = lal.CreateCOMPLEX16FrequencySeries("",
lal.LIGOTimeGPS(self.start_time),
self.frequency_array[0],
(self.frequency_array[1] - self.frequency_array[0]),
lal.SecondUnit,
len(self.frequency_domain_strain))
laldata.data.data[:] = self.frequency_domain_strain
return laldata
def to_pycbc_timeseries(self):
"""
Output the time series strain data as a :class:`pycbc.types.timeseries.TimeSeries`.
"""
try:
import pycbc
except ImportError:
raise ImportError("Cannot output strain data as PyCBC TimeSeries")
return pycbc.types.timeseries.TimeSeries(
self.time_domain_strain,
delta_t=(1. / self.sampling_frequency),
epoch=lal.LIGOTimeGPS(self.start_time))
def __init__(self, mass1, mass2, S, f_low, approximant, amplitude_order,
phase_order):
"""Create a TaylorF2 signal model with the given masses, PSD function
S(f), PN amplitude order, and low-frequency cutoff."""
if approximant == lalsimulation.TaylorF2:
# Frequency-domain post-Newtonian inspiral waveform.
h, _ = lalsimulation.SimInspiralChooseFDWaveform(
0, 1, mass1 * lal.LAL_MSUN_SI, mass2 * lal.LAL_MSUN_SI, 0, 0,
0, 0, 0, 0, f_low, 0, 1e6 * lal.LAL_PC_SI, 0, 0, 0, None, None,
amplitude_order, 0, approximant)
# Find indices of first and last nonzero samples.
nonzero = np.nonzero(h.data.data)[0]
first_nonzero = nonzero[0]
last_nonzero = nonzero[-1]
elif approximant == lalsimulation.TaylorT4:
# Time-domain post-Newtonian inspiral waveform.
hplus, hcross = lalsimulation.SimInspiralChooseTDWaveform(
0, 1 / 4096, mass1 * lal.LAL_MSUN_SI, mass2 * lal.LAL_MSUN_SI,
0, 0, 0, 0, 0, 0, f_low, f_low, 1e6 * lal.LAL_PC_SI, 0, 0, 0,
None, None, amplitude_order, phase_order, approximant)
hplus.data.data += hcross.data.data
hplus.data.data /= np.sqrt(2)
h = lal.CreateCOMPLEX16FrequencySeries(
None, lal.LIGOTimeGPS(0), 0, 0, lal.lalDimensionlessUnit,
len(hplus.data.data) // 2 + 1)
plan = CreateForwardREAL8FFTPlan(len(hplus.data.data), 0)
lal.REAL8TimeFreqFFT(h, hplus, plan)
f = h.f0 + len(h.data.data) * h.deltaF
first_nonzero = long(np.floor((f_low - h.f0) / h.deltaF))
last_nonzero = long(np.ceil((2048 - h.f0) / h.deltaF))
last_nonzero = min(last_nonzero, len(h.data.data) - 1)
else:
raise ValueError("unrecognized approximant")
# Frequency sample points
self.dw = 2 * np.pi * h.deltaF
f = h.f0 + h.deltaF * np.arange(first_nonzero, last_nonzero + 1)
self.w = 2 * np.pi * f
# Throw away leading and trailing zeros.
h = h.data.data[first_nonzero:last_nonzero + 1]
self.denom_integrand = 4 / (2 * np.pi) * (np.square(h.real) +
np.square(h.imag)) / S(f)
self.den = np.trapz(self.denom_integrand, dx=self.dw)
def test_one():
par = PulsarParametersPy()
par['F'] = [123.456789, -9.87654321e-12] # set frequency
par['DELTAF'] = [0.0, 0.0] # frequency difference
par['RAJ'] = lal.TranslateHMStoRAD('01:23:34.5') # set right ascension
par['DECJ'] = lal.TranslateDMStoRAD('-45:01:23.4') # set declination
pepoch = lal.TranslateStringMJDTTtoGPS('58000')
par['PEPOCH'] = pepoch.gpsSeconds + 1e-9 * pepoch.gpsNanoSeconds
par['H0'] = 5.6e-26
par['COSIOTA'] = -0.2
par['PSI'] = 0.4
par['PHI0'] = 2.3
freqfactor = 2. # set frequency factor
for det in t1output.keys():
# convert into GPS times
gpstimes = lalpulsar.CreateTimestampVector(len(t1output[det]))
for i, time in enumerate(t1output[det][:, 0]):
gpstimes.data[i] = lal.LIGOTimeGPS(time)
detector = lalpulsar.GetSiteInfo(det)
# set the response function look-up table
dt = t1output[det][1, 0] - t1output[det][0, 0] # time step
resp = lalpulsar.DetResponseLookupTable(t1output[det][0, 0], detector,
par['RAJ'], par['DECJ'], 2880,
dt)
# get the heterodyned file SSB delay
hetSSBdelay = lalpulsar.HeterodynedPulsarGetSSBDelay(
par.PulsarParameters(), gpstimes, detector, edat, tdat,
lalpulsar.TIMECORRECTION_TCB)
fullsignal = lalpulsar.HeterodynedPulsarGetModel(
par.PulsarParameters(), freqfactor, 1, 0, 0, gpstimes, hetSSBdelay,
0, None, 0, resp, edat, tdat, lalpulsar.TIMECORRECTION_TCB)
# check output matches that from lalapps_pulsar_parameter_estimation_nested
if np.any(
np.abs(fullsignal.data.data.real -
t1output[det][:, 1]) > 1e-34):
return False
elif np.any(
np.abs(fullsignal.data.data.imag -
t1output[det][:, 2]) > 1e-34):
return False
return True
def parseTimeDelayDegeneracy(self, ifos, gpstime=lal.GPSTimeNow(),\
dt=0.0005):
# get detectors
detectors = [cached_detector.get(prefix_to_name[ifo])\
for ifo in ifos]
timeDelays = []
degenerate = []
new = table.new_from_template(self)
for n, row in enumerate(self):
# get all time delays for this point
timeDelays.append([])
for i in xrange(len(ifos)):
for j in xrange(i + 1, len(ifos)):
timeDelays[n].append(lal.ArrivalTimeDiff(\
detectors[i].location,\
detectors[j].location,\
row.longitude,\
row.latitude,\
lal.LIGOTimeGPS(gpstime)))
# skip the first point
if n == 0:
degenerate.append(False)
new.append(row)
continue
else:
degenerate.append(True)
# test this point against all others
for i in xrange(0, n):
# if check point is degenerate, skip
if degenerate[i]:
continue
# check each time delay individually
for j in xrange(0, len(timeDelays[n])):
# if this time delay is non-degenerate the point is valid
if np.fabs(timeDelays[i][j] - timeDelays[n][j]) >= dt:
degenerate[n] = False
break
else:
degenerate[n] = True
if degenerate[n]:
break
if not degenerate[n]:
new.append(row)
return new
def __init__(self, *args):
self.context = context
self.dtype = dtype
self.odtype = odtype
if _options['scheme'] == 'cpu':
self.scheme = type(None)
elif _options['scheme'] == 'cuda':
self.scheme = pycbc.scheme.CUDAScheme
else:
self.scheme = pycbc.scheme.OpenCLScheme
if epoch is None:
self.epoch = lal.LIGOTimeGPS(0, 0)
else:
self.epoch = epoch
unittest.TestCase.__init__(self, *args)
def __init__(self,
initial_array,
delta_f,
epoch=None,
dtype=None,
copy=True):
"""initial_array: array containing sampled data.
delta_f: frequency between consecutive samples in Hertz.
epoch: start time of the associated time domain data, in seconds.
Must be a lal.LIGOTimeGPS object.
"""
if len(initial_array) < 1:
raise ValueError('initial_array must contain at least one sample.')
if not delta_f > 0:
raise ValueError('delta_f must be a positive number')
if epoch is not None and not isinstance(epoch, _lal.LIGOTimeGPS):
raise TypeError('epoch must be either None or a lal.LIGOTimeGPS')
if epoch is None:
epoch = _lal.LIGOTimeGPS(0, 0)
else:
epoch = _lal.LIGOTimeGPS(epoch)
Array.__init__(self, initial_array, dtype=dtype, copy=copy)
self._delta_f = delta_f
self._epoch = epoch
def test_coordframe_project_strain(self):
""" Check consistency of project_strain() with skypoints in different cooordinate frames
"""
coords = numpy.array([uniform(0,360), uniform(-90,90)])
pt_eq = pb.skymaps.Skypoint(*numpy.radians(coords), COORD_SYS_EQUATORIAL)
pt_geo = pt_eq.transformed_to(COORD_SYS_GEOGRAPHIC)
d = pb.detectors.Detector(random.choice(DETECTORS))
hplus = TimeSeries(SIN_1_SEC, sample_rate=SAMPLING_RATE).to_lal()
hcross = TimeSeries(ZEROS_1_SEC, sample_rate=SAMPLING_RATE).to_lal()
hplus.epoch = lal.LIGOTimeGPS(TIME)
hcross.epoch = lal.LIGOTimeGPS(TIME)
# Project wave onto detector
response_eq = d.project_strain(hplus, hcross, pt_eq, 0)
response_geo = d.project_strain(hplus, hcross, pt_geo, 0)
err = numpy.abs(response_eq-response_geo)
# self.assertEqual(response_eq, response_geo)
self.assertTrue(numpy.allclose(numpy.abs(err), 0))
def test_fplus_project_strain(self):
""" Check consistency of project_strain() against antenna_pattern()
"""
coords = numpy.array([uniform(0,360), uniform(-90,90)])
psi = math.radians(uniform(0,180))
pt_eq = pb.skymaps.Skypoint(*numpy.radians(coords), COORD_SYS_EQUATORIAL)
d = pb.detectors.Detector(random.choice(DETECTORS))
antenna_pat = d.antenna_pattern(pt_eq, time=TIME, psi=psi)
hplus = TimeSeries(SIN_1_SEC, sample_rate=SAMPLING_RATE).to_lal()
hcross = TimeSeries(ZEROS_1_SEC, sample_rate=SAMPLING_RATE).to_lal()
hplus.epoch = lal.LIGOTimeGPS(TIME)
hcross.epoch = lal.LIGOTimeGPS(TIME)
# Project wave onto detector
response = d.project_strain(hplus, hcross, pt_eq, psi)
# Generate support timeseries
data = TimeSeries(ZEROS_5_SEC, \
sample_rate=SAMPLING_RATE, \
t0=TIME-2, unit=response._unit)
# Inject signal into timeseries
h = data.inject(response)
if antenna_pat[0] > 0:
estimated_pat = h.max().to_value()
else:
estimated_pat = h.min().to_value()
print("Exact antenna pattern = {} ; Estimated amplitude = {}".format(antenna_pat[0], estimated_pat))
# Estimate delay from timeseries
self.assertAlmostEqual(antenna_pat[0], estimated_pat, places=2)
def __init__(self,
initial_array,
delta_t=None,
epoch=None,
dtype=None,
copy=True):
if len(initial_array) < 1:
raise ValueError('initial_array must contain at least one sample.')
if delta_t is None:
try:
delta_t = initial_array.delta_t
except AttributeError:
raise TypeError(
'must provide either an initial_array with a delta_t attribute, or a value for delta_t'
)
if not delta_t > 0:
raise ValueError('delta_t must be a positive number')
# Get epoch from initial_array if epoch not given (or is None)
# If initialy array has no epoch, set epoch to 0.
# If epoch is provided, use that.
if not isinstance(epoch, _lal.LIGOTimeGPS):
if epoch is None:
if isinstance(initial_array, TimeSeries):
epoch = initial_array._epoch
else:
epoch = _lal.LIGOTimeGPS(0)
elif epoch is not None:
try:
epoch = _lal.LIGOTimeGPS(epoch)
except:
raise TypeError(
'epoch must be either None or a lal.LIGOTimeGPS')
Array.__init__(self, initial_array, dtype=dtype, copy=copy)
self._delta_t = delta_t
self._epoch = epoch
def test_injection_presence(self):
"""Verify presence of signals at expected times"""
injections = InjectionSet(self.inj_file.name)
for det in self.detectors:
for inj in self.injections:
ts = TimeSeries(numpy.zeros(int(10 * self.sample_rate)),
delta_t=1 / self.sample_rate,
epoch=lal.LIGOTimeGPS(inj.end_time - 5),
dtype=numpy.float64)
injections.apply(ts, det.name)
max_amp, max_loc = ts.abs_max_loc()
# FIXME could test amplitude and time more precisely
self.assertTrue(max_amp > 0 and max_amp < 1e-10)
time_error = ts.sample_times.numpy()[max_loc] - inj.end_time
self.assertTrue(abs(time_error) < 2 * self.earth_time)
def to_pycbc_frequencyseries(self):
"""
Output the frequency series strain data as a :class:`pycbc.types.frequencyseries.FrequencySeries`.
"""
try:
import pycbc
except ImportError:
raise ImportError(
"Cannot output strain data as PyCBC FrequencySeries")
return pycbc.types.frequencyseries.FrequencySeries(
self.frequency_domain_strain,
delta_f=(self.frequency_array[1] - self.frequency_array[0]),
epoch=lal.LIGOTimeGPS(self.start_time))
def generate_PSD(psd_name="aLIGOZeroDetHighPower", length=None, delta_f=None):
psd_list = get_lalsim_psd_list()
if psd_name in psd_list:
# print (psd_name)
# Function for PSD
func = lalsim.__dict__["SimNoisePSD" + psd_name + "Ptr"]
# Generate a lal frequency series
PSDseries = lal.CreateREAL8FrequencySeries("", lal.LIGOTimeGPS(0), 0,
delta_f,
lal.DimensionlessUnit,
length)
# func(PSDseries)
lalsim.SimNoisePSD(PSDseries, 0, func)
return PSDseries
def to_lal_ligotimegps(gps):
"""Convert the given GPS time to a `lal.LIGOTimeGPS` object
Parameters
----------
gps : `~gwpy.time.LIGOTimeGPS`, `float`, `str`
input GPS time, can be anything parsable by :meth:`~gwpy.time.to_gps`
Returns
-------
ligotimegps : `lal.LIGOTimeGPS`
a SWIG-LAL `~lal.LIGOTimeGPS` representation of the given GPS time
"""
gps = to_gps(gps)
return lal.LIGOTimeGPS(gps.gpsSeconds, gps.gpsNanoSeconds)
def gen_psd(fs, T_obs, op='AdvDesign', det='H1'):
""" generates noise for a variety of different detectors
Parameters
----------
fs:
sampling frequency
T_obs:
observation time window
op:
type of noise curve
det:
detector
Returns
-------
psd:
noise power spectral density
"""
N = T_obs * fs # the total number of time samples
dt = 1 / fs # the sampling time (sec)
df = 1 / T_obs # the frequency resolution
psd = lal.CreateREAL8FrequencySeries(None, lal.LIGOTimeGPS(0), 0.0, df,
lal.HertzUnit, N // 2 + 1)
if det == 'H1' or det == 'L1':
if op == 'AdvDesign':
lalsimulation.SimNoisePSDAdVDesignSensitivityP1200087(psd, 10.0)
elif op == 'AdvEarlyLow':
lalsimulation.SimNoisePSDAdVEarlyLowSensitivityP1200087(psd, 10.0)
elif op == 'AdvEarlyHigh':
lalsimulation.SimNoisePSDAdVEarlyHighSensitivityP1200087(psd, 10.0)
elif op == 'AdvMidLow':
lalsimulation.SimNoisePSDAdVMidLowSensitivityP1200087(psd, 10.0)
elif op == 'AdvMidHigh':
lalsimulation.SimNoisePSDAdVMidHighSensitivityP1200087(psd, 10.0)
elif op == 'AdvLateLow':
lalsimulation.SimNoisePSDAdVLateLowSensitivityP1200087(psd, 10.0)
elif op == 'AdvLateHigh':
lalsimulation.SimNoisePSDAdVLateHighSensitivityP1200087(psd, 10.0)
else:
print 'unknown noise option'
exit(1)
else:
print 'unknown detector - will add Virgo soon'
exit(1)
return psd
def test_injection_absence(self):
"""Verify absence of signals outside known injection times"""
clear_times = [
self.injections[0].end_time - 86400,
self.injections[-1].end_time + 86400
]
injections = InjectionSet(self.inj_file.name)
for det in self.detectors:
for epoch in clear_times:
ts = TimeSeries(numpy.zeros(int(10 * self.sample_rate)),
delta_t=1 / self.sample_rate,
epoch=lal.LIGOTimeGPS(epoch),
dtype=numpy.float64)
injections.apply(ts, det.name)
max_amp, max_loc = ts.abs_max_loc()
self.assertEqual(max_amp, 0)
def get_PSD_from_xml(PSD_filename, df, f_min=15., f_max=1024.):
"Gets the PSD from lal from an ASD file"
PSD = lal.CreateREAL8FrequencySeries('PSD', lal.LIGOTimeGPS(0), 0.0, df,
lal.SecondUnit,
int(round(f_max / df)) + 1)
#FIXME: how shall I read the PSD??
lalsimulation.SimNoisePSDFromFile(PSD, f_min, filename)
#see documentation here:
#https://lscsoft.docs.ligo.org/lalsuite/lalsimulation/group___l_a_l_sim_noise_p_s_d__c.html#ga67d250556e4e8647c50d379364eb7911
# SimNoisePSDFromFile expects ASD in the file, but this one
# contains the PSD, so take the square root
PSD.data.data = PSD.data.data**0.5
return PSD
def to_lal(self):
"""Convert this `TimeSeries` into a LAL TimeSeries.
"""
import lal
from ..utils.lal import (LAL_TYPE_STR_FROM_NUMPY, to_lal_unit)
typestr = LAL_TYPE_STR_FROM_NUMPY[self.dtype.type]
try:
unit = to_lal_unit(self.unit)
except ValueError as e:
warnings.warn("%s, defaulting to lal.DimensionlessUnit" % str(e))
unit = lal.DimensionlessUnit
create = getattr(lal, 'Create%sTimeSeries' % typestr.upper())
lalts = create(self.name, lal.LIGOTimeGPS(self.epoch.gps), 0,
self.dt.value, unit, self.size)
lalts.data.data = self.value
return lalts
def fill_sim_inspiral_row(self, row):
# using dummy values for many fields, should work for our purposes
row.waveform = 'TaylorT4threePointFivePN'
row.distance = self.distance
total_mass = self.mass1 + self.mass2
row.mass1 = self.mass1
row.mass2 = self.mass2
row.eta = self.mass1 * self.mass2 / total_mass**2
row.mchirp = total_mass * row.eta**(3. / 5.)
row.latitude = self.latitude
row.longitude = self.longitude
row.inclination = self.inclination
row.polarization = self.polarization
row.phi0 = 0
row.f_lower = 20
row.f_final = lal.C_SI ** 3 / \
(6. ** (3. / 2.) * lal.PI * lal.G_SI * total_mass)
row.spin1x = row.spin1y = row.spin1z = 0
row.spin2x = row.spin2y = row.spin2z = 0
row.alpha1 = 0
row.alpha2 = 0
row.alpha3 = 0
row.alpha4 = 0
row.alpha5 = 0
row.alpha6 = 0
row.alpha = 0
row.beta = 0
row.theta0 = 0
row.psi0 = 0
row.psi3 = 0
row.geocent_end_time = int(self.end_time)
row.geocent_end_time_ns = int(1e9 *
(self.end_time - row.geocent_end_time))
row.end_time_gmst = lal.GreenwichMeanSiderealTime(
lal.LIGOTimeGPS(self.end_time))
for d in 'lhvgt':
row.__setattr__('eff_dist_' + d, row.distance)
row.__setattr__(d + '_end_time', row.geocent_end_time)
row.__setattr__(d + '_end_time_ns', row.geocent_end_time_ns)
row.amp_order = 0
row.coa_phase = 0
row.bandpass = 0
row.taper = self.taper
row.numrel_mode_min = 0
row.numrel_mode_max = 0
row.numrel_data = None
row.source = 'ANTANI'
def times(self, times):
"""
Set an array of times, and also a ``LIGOTimeGPSVector()`` containing
the times.
Parameters
----------
times: array_like
An array of GPS times. This can be a :class:`astropy.time.Time`
object, for which inputs will be converted to GPS is not already
held as GPS times.
"""
from astropy.time import Time
if times is None:
self.__times = None
self.__gpstimes = None
return
elif isinstance(times, lal.LIGOTimeGPS):
self.__times = np.array(
[times.gpsSeconds + 1e-9 * times.gpsNanoSeconds], dtype=np.float128
)
self.__gpstimes = lalpulsar.CreateTimestampVector(1)
self.__gpstimes.data[0] = times
return
elif isinstance(times, lalpulsar.LIGOTimeGPSVector):
self.__gpstimes = times
self.__times = np.zeros(len(times.data), dtype=np.float128)
for i in range(len(times.data)):
self.__times[i] = (
times.data[i].gpsSeconds + 1e-9 * times.data[i].gpsNanoSeconds
)
return
elif isinstance(times, (int, float, np.float128, list, tuple, np.ndarray)):
self.__times = np.atleast_1d(np.array(times, dtype=np.float128))
elif isinstance(times, Time):
self.__times = np.atleast_1d(times.gps).astype(np.float128)
else:
raise TypeError("Unknown data type for times")
self.__gpstimes = lalpulsar.CreateTimestampVector(len(self.__times))
for i, time in enumerate(self.__times):
seconds = int(np.floor(time))
nanoseconds = int((time - seconds) * 1e9)
self.__gpstimes.data[i] = lal.LIGOTimeGPS(seconds, nanoseconds)
def getPSD(deltaF, npts, psd="SimNoisePSDaLIGOZeroDetHighPowerPtr"):
"""
deltaF :: The frequency interval between data points.
npts :: Total number of date points
psd :: The noise model in lalsimulation. To get info use
lalsim.__dict__ in interpretor and search string SimNoisePSD
"""
lalseries = lal.CreateREAL8FrequencySeries('', lal.LIGOTimeGPS(0), 0,
deltaF, lal.DimensionlessUnit,
npts)
func = lalsim.__dict__[psd]
lalsim.SimNoisePSD(lalseries, 0, func)
f_end = lalseries.f0 + len(lalseries.data.data) * lalseries.deltaF
freq = np.linspace(lalseries.f0, f_end, len((lalseries.data.data)))
output = np.vstack((freq, lalseries.data.data)).T
return output
def get_coincs_from_coire(self,files,stat='snr'):
"""
uses CoincInspiralUtils to get data from old-style (coire'd) coincs
"""
coincTrigs = CoincInspiralUtils.coincInspiralTable()
inspTrigs = SnglInspiralUtils.ReadSnglInspiralFromFiles(files, \
mangle_event_id = True,verbose=None)
statistic = CoincInspiralUtils.coincStatistic(stat,None,None)
coincTrigs = CoincInspiralUtils.coincInspiralTable(inspTrigs,statistic)
try:
inspInj = SimInspiralUtils.ReadSimInspiralFromFiles(files)
coincTrigs.add_sim_inspirals(inspInj)
#FIXME: name the exception!
except:
pass
#now extract the relevant information into CoincData objects
for ctrig in coincTrigs:
coinc = CoincData()
coinc.set_ifos(ctrig.get_ifos()[1])
coinc.set_gps(dict((trig.ifo,lal.LIGOTimeGPS(trig.get_end())) for trig in ctrig))
coinc.set_snr(dict((trig.ifo,getattr(ctrig,trig.ifo).snr) for trig in ctrig))
coinc.set_effDs(dict((trig.ifo,getattr(ctrig,trig.ifo).eff_distance) for trig in ctrig))
coinc.set_masses(dict((trig.ifo,getattr(ctrig,trig.ifo).mass1) for trig in ctrig), \
dict((trig.ifo,getattr(ctrig,trig.ifo).mass2) for trig in ctrig))
try:
effDs_inj = {}
for ifo in coinc.ifo_list:
if ifo == 'H1':
effDs_inj[ifo] = getattr(ctrig,'sim').eff_dist_h
elif ifo == 'L1':
effDs_inj[ifo] = getattr(ctrig,'sim').eff_dist_l
elif ifo == 'V1':
effDs_inj[ifo] = getattr(ctrig,'sim').eff_dist_v
dist_inj = getattr(ctrig,'sim').distance
coinc.set_inj_params(getattr(ctrig,'sim').latitude,getattr(ctrig,'sim').longitude, \
getattr(ctrig,'sim').mass1,getattr(ctrig,'sim').mass2,dist_inj,effDs_inj)
coinc.is_injection = True
#FIXME: name the exception!
except:
pass
self.append(coinc)
def MaxTimeDelayLine3(ifo1, ifo2, ra, dec, gpstime=None, n=3):
"""
Alternative implementation of MaxTimeDelayLine.
"""
if gpstime:
gpstime = lal.LIGOTimeGPS(gpstime)
p = SkyPosition()
p.longitude = ra
p.latitude = dec
p.system = 'equatorial'
p.probability = None
p.solid_angle = None
if gpstime:
p = EquatorialToGeographic(p, gpstime)
cart = SphericalToCartesian(p)
# get baseline
detectors = [cached_detector.get(prefix_to_name[ifo])\
for ifo in [ifo1,ifo2]]
baseline = detectors[0].location - detectors[1].location
baseline = baseline / np.linalg.norm(baseline)
# get angular spacing
dtheta = lal.TWOPI / n
# get axis and angle of rotation
north = np.array([0, 0, 1])
axis = np.cross(cart, baseline)
axis = axis / np.linalg.norm(axis)
R = _rotation(axis, dtheta)
# set up list
l = SkyPositionTable()
# append central point
l.append(p)
for i in xrange(1, n):
l.append(l[i - 1].rotate(R))
if gpstime:
for i, p in enumerate(l):
l[i] = GeographicToEquatorial(p, gpstime)
return l
def __init__(self, name, ref_time=None):
"""
name -- name of the coordinate system
ref_time: reference time for sky-fixed coordinate systems
ref_time is None for the Earth-fixed (geocentric) coordinate system.
"""
self.name = name
assert self.is_valid(), "Unsupported coordinate system"
if name=='geographic':
assert ref_time is None, \
'ref_time must be None for Earth-fixed coordinate system'
else:
assert ref_time is not None, \
'ref_time must be provided for sky-fixed coordinate systems'
self.ref_time = lal.LIGOTimeGPS(ref_time) if ref_time is not None else None
def apply_taper(TimeSeries, newlen=16384):
"""
Smoothly taper the start of the data in TimeSeries using LAL tapering
routines
Also zero pads
"""
# Create and populate lal time series
tmp = lal.CreateREAL8TimeSeries('tmp', lal.LIGOTimeGPS(), 0.0,
TimeSeries.delta_t, lal.StrainUnit, newlen)
#TimeSeries.delta_t, lal.StrainUnit, len(TimeSeries))
tmp.data.data = np.zeros(newlen)
tmp.data.data[0:len(TimeSeries)] = TimeSeries.data
# Taper
lalsim.SimInspiralREAL8WaveTaper(tmp.data, lalsim.SIM_INSPIRAL_TAPER_START)
return pycbc.types.TimeSeries(tmp.data.data, delta_t=TimeSeries.delta_t)
def get_frequency(self, t):
DeltaFDrift = self.F1 * (t - self.tref)
phir = 2 * np.pi * t / self.Pmod + self.Pmod_phi
if self.Alpha is not None and self.Delta is not None:
spin_posvel = lalpulsar.PosVel3D_t()
orbit_posvel = lalpulsar.PosVel3D_t()
det = lal.CachedDetectors[4]
ephems = lalpulsar.InitBarycenter(self.earth_ephem, self.sun_ephem)
lalpulsar.DetectorPosVel(
spin_posvel,
orbit_posvel,
lal.LIGOTimeGPS(t),
det,
ephems,
lalpulsar.DETMOTION_ORBIT,
)
# Pos and vel returned in units of c
DeltaFOrbital = np.dot(self.n, orbit_posvel.vel) * self.Fmax
if self.IFO == "H1":
Lambda = lal.LHO_4K_DETECTOR_LATITUDE_RAD
elif self.IFO == "L1":
Lambda = lal.LLO_4K_DETECTOR_LATITUDE_RAD
DeltaFSpin = (
self.Pmod_amp
* lal.REARTH_SI
/ lal.C_SI
* 2
* np.pi
/ self.Pmod
* (np.cos(self.Delta) * np.cos(Lambda) * np.sin(self.Alpha - phir))
* self.Fmax
)
else:
DeltaFOrbital = 0
DeltaFSpin = 2 * np.pi * self.Pmod_amp / self.Pmod * np.cos(phir)
f = self.F0 + DeltaFDrift + DeltaFOrbital + DeltaFSpin
return f
def __getitem__(self, coinc_id):
template_id = self.template_ids[coinc_id]
timeslide_id = self.timeslide_ids[coinc_id]
template = [col[template_id] for col in self.bank]
trigger_ids = [
trigger_ids[coinc_id] for trigger_ids in self.trigger_ids
]
return [
self.SnglInspiral(
trigger_id, ifo, triggers[0][trigger_id],
triggers[1][trigger_id],
lal.LIGOTimeGPS(triggers[2][trigger_id] +
(timeslide_id *
self.timeslide_interval if i == 0 else 0)),
*template)
for i, (trigger_id, ifo, triggers
) in enumerate(zip(trigger_ids, self.ifos, self.triggers))
]
