def generate(self, *args):
"""Generates a waveform, applies a time shift and the detector response
function."""
self.current_params.update(dict(zip(self.variable_args, args)))
# FIXME: use the following when we switch to 2.7
# rfparams = {param: self.current_params[param]
# for param in self.rframe_generator.variable_args}
rfparams = dict([(param, self.current_params[param]) for param in self.rframe_generator.variable_args])
hp, hc = self.rframe_generator.generate_from_kwargs(**rfparams)
h = {}
if self.detector_names != ["RF"]:
# we'll need the frequency points for applying the time shift
fseries = hp.sample_frequencies.numpy()
for detname, det in self.detectors.items():
# apply detector response function
fp, fc = det.antenna_pattern(
self.current_params["ra"],
self.current_params["dec"],
self.current_params["polarization"],
self.current_params["tc"],
)
thish = fp * hp + fc * hc
# apply the time shift
tc = self.current_params["tc"] + det.time_delay_from_earth_center(
self.current_params["ra"], self.current_params["dec"], self.current_params["tc"]
)
h[detname] = apply_fd_time_shift(thish, tc, fseries=fseries, copy=False)
elif "tc" in self.current_params:
# apply the time shift if specified
fseries = hp.sample_frequencies.numpy()
h["RF"] = apply_fd_time_shift(hp, self.current_params["tc"], fseries=fseries, copy=False)
else:
# just return the plus polarization
h["RF"] = hp
return h
def generate(self, **kwargs):
"""Generates a waveform, applies a time shift and the detector response
function from the given kwargs.
"""
self.current_params.update(kwargs)
rfparams = {
param: self.current_params[param]
for param in kwargs if param not in self.location_args
}
hp, hc = self.rframe_generator.generate(**rfparams)
if isinstance(hp, TimeSeries):
df = self.current_params['delta_f']
hp = hp.to_frequencyseries(delta_f=df)
hc = hc.to_frequencyseries(delta_f=df)
# time-domain waveforms will not be shifted so that the peak amp
# happens at the end of the time series (as they are for f-domain),
# so we add an additional shift to account for it
tshift = 1. / df - abs(hp._epoch)
else:
tshift = 0.
hp._epoch = hc._epoch = self._epoch
h = {}
if self.detector_names != ['RF']:
for detname, det in self.detectors.items():
# apply detector response function
fp, fc = det.antenna_pattern(
self.current_params['ra'], self.current_params['dec'],
self.current_params['polarization'],
self.current_params['tc'])
thish = fp * hp + fc * hc
# apply the time shift
tc = self.current_params['tc'] + \
det.time_delay_from_earth_center(self.current_params['ra'],
self.current_params['dec'], self.current_params['tc'])
h[detname] = apply_fd_time_shift(thish,
tc + tshift,
copy=False)
if self.recalib:
# recalibrate with given calibration model
h[detname] = \
self.recalib[detname].map_to_adjust(h[detname],
**self.current_params)
else:
# no detector response, just use the + polarization
if 'tc' in self.current_params:
hp = apply_fd_time_shift(hp,
self.current_params['tc'] + tshift,
copy=False)
h['RF'] = hp
if self.gates is not None:
# resize all to nearest power of 2
for d in h.values():
d.resize(ceilpow2(len(d) - 1) + 1)
h = strain.apply_gates_to_fd(h, self.gates)
return h
def generate(self, **kwargs):
"""Generates a waveform, applies a time shift and the detector response
function from the given kwargs.
"""
self.current_params.update(kwargs)
rfparams = {param: self.current_params[param]
for param in kwargs if param not in self.location_args}
hp, hc = self.rframe_generator.generate(**rfparams)
if isinstance(hp, TimeSeries):
df = self.current_params['delta_f']
hp = hp.to_frequencyseries(delta_f=df)
hc = hc.to_frequencyseries(delta_f=df)
# time-domain waveforms will not be shifted so that the peak amp
# happens at the end of the time series (as they are for f-domain),
# so we add an additional shift to account for it
tshift = 1./df - abs(hp._epoch)
else:
tshift = 0.
hp._epoch = hc._epoch = self._epoch
h = {}
if self.detector_names != ['RF']:
for detname, det in self.detectors.items():
# apply detector response function
fp, fc = det.antenna_pattern(self.current_params['ra'],
self.current_params['dec'],
self.current_params['polarization'],
self.current_params['tc'])
thish = fp*hp + fc*hc
# apply the time shift
tc = self.current_params['tc'] + \
det.time_delay_from_earth_center(self.current_params['ra'],
self.current_params['dec'], self.current_params['tc'])
h[detname] = apply_fd_time_shift(thish, tc+tshift, copy=False)
if self.recalib:
# recalibrate with given calibration model
h[detname] = \
self.recalib[detname].map_to_adjust(h[detname],
**self.current_params)
else:
# no detector response, just use the + polarization
if 'tc' in self.current_params:
hp = apply_fd_time_shift(hp, self.current_params['tc']+tshift,
copy=False)
h['RF'] = hp
if self.gates is not None:
# resize all to nearest power of 2
for d in h.values():
d.resize(ceilpow2(len(d)-1) + 1)
h = gate.apply_gates_to_fd(h, self.gates)
return h
def _shift_and_ifft(self, fdsinx, tshift, fseries=None):
"""Calls apply_fd_time_shift, and iFFTs to the time domain.
"""
start_time = self.time_series.start_time
tdshift = apply_fd_time_shift(fdsinx, start_time+tshift,
fseries=fseries)
return tdshift.to_timeseries()
def generate(self, *args):
"""Generates a waveform, applies a time shift and the detector response
function."""
self.current_params.update(dict(zip(self.variable_args, args)))
# FIXME: use the following when we switch to 2.7
#rfparams = {param: self.current_params[param]
# for param in self.rframe_generator.variable_args}
rfparams = dict([(param, self.current_params[param])
for param in self.rframe_generator.variable_args])
hp, hc = self.rframe_generator.generate_from_kwargs(**rfparams)
hp._epoch = hc._epoch = self._epoch
h = {}
if 'tc' in self.current_params:
try:
kmin = int(self.current_params['f_lower'] / hp.delta_f)
except KeyError:
kmin = 0
if self.detector_names != ['RF']:
for detname, det in self.detectors.items():
# apply detector response function
fp, fc = det.antenna_pattern(
self.current_params['ra'], self.current_params['dec'],
self.current_params['polarization'],
self.current_params['tc'])
thish = fp * hp + fc * hc
# apply the time shift
tc = self.current_params['tc'] + \
det.time_delay_from_earth_center(self.current_params['ra'],
self.current_params['dec'],
self.current_params['tc'])
h[detname] = apply_fd_time_shift(thish,
tc,
kmin=kmin,
copy=False)
else:
# no detector response, just use the + polarization
if 'tc' in self.current_params:
hp = apply_fd_time_shift(hp,
self.current_params['tc'],
kmin=kmin,
copy=False)
h['RF'] = hp
return h
def generate(self, *args):
"""Generates a waveform, applies a time shift and the detector response
function."""
self.current_params.update(dict(zip(self.variable_args, args)))
# FIXME: use the following when we switch to 2.7
#rfparams = {param: self.current_params[param]
# for param in self.rframe_generator.variable_args}
rfparams = dict([(param, self.current_params[param])
for param in self.rframe_generator.variable_args])
hp, hc = self.rframe_generator.generate_from_kwargs(**rfparams)
if isinstance(hp, TimeSeries):
df = self.current_params['delta_f']
hp = hp.to_frequencyseries(delta_f=df)
hc = hc.to_frequencyseries(delta_f=df)
# time-domain waveforms will not be shifted so that the peak amp
# happens at the end of the time series (as they are for f-domain),
# so we add an additional shift to account for it
tshift = 1./df - abs(hp._epoch)
else:
tshift = 0.
hp._epoch = hc._epoch = self._epoch
h = {}
if self.detector_names != ['RF']:
for detname, det in self.detectors.items():
# apply detector response function
fp, fc = det.antenna_pattern(self.current_params['ra'],
self.current_params['dec'],
self.current_params['polarization'],
self.current_params['tc'])
thish = fp*hp + fc*hc
# apply the time shift
tc = self.current_params['tc'] + \
det.time_delay_from_earth_center(self.current_params['ra'],
self.current_params['dec'], self.current_params['tc'])
h[detname] = apply_fd_time_shift(thish, tc+tshift, copy=False)
else:
# no detector response, just use the + polarization
if 'tc' in self.current_params:
hp = apply_fd_time_shift(hp, self.current_params['tc']+tshift,
copy=False)
h['RF'] = hp
return h
def _shift_and_ifft(self, fdsinx, tshift, fseries=None):
"""Calls apply_fd_time_shift, and iFFTs to the time domain.
"""
start_time = self.time_series.start_time
tdshift = apply_fd_time_shift(fdsinx, start_time+tshift,
fseries=fseries)
if not isinstance(tdshift, FrequencySeries):
# cast to FrequencySeries so time series will work
tdshift = FrequencySeries(tdshift, delta_f=fdsinx.delta_f,
epoch=fdsinx.epoch)
return tdshift.to_timeseries()
def generate(self, **kwargs):
"""Generates a waveform, applies a time shift and the detector response
function from the given kwargs.
"""
self.current_params.update(kwargs)
rfparams = {param: self.current_params[param]
for param in self.rframe_generator.variable_args}
hp, hc = self.rframe_generator.generate(**rfparams)
if isinstance(hp, TimeSeries):
df = self.current_params['delta_f']
hp = hp.to_frequencyseries(delta_f=df)
hc = hc.to_frequencyseries(delta_f=df)
# time-domain waveforms will not be shifted so that the peak amp
# happens at the end of the time series (as they are for f-domain),
# so we add an additional shift to account for it
tshift = 1./df - abs(hp._epoch)
else:
tshift = 0.
hp._epoch = hc._epoch = self._epoch
h = {}
if self.detector_names != ['RF']:
for detname, det in self.detectors.items():
# apply detector response function
fp, fc = det.antenna_pattern(self.current_params['ra'],
self.current_params['dec'],
self.current_params['polarization'],
self.current_params['tc'])
thish = fp*hp + fc*hc
# apply the time shift
tc = self.current_params['tc'] + \
det.time_delay_from_earth_center(self.current_params['ra'],
self.current_params['dec'], self.current_params['tc'])
h[detname] = apply_fd_time_shift(thish, tc+tshift, copy=False)
else:
# no detector response, just use the + polarization
if 'tc' in self.current_params:
hp = apply_fd_time_shift(hp, self.current_params['tc']+tshift,
copy=False)
h['RF'] = hp
return h
def _shift_and_ifft(self, fdsinx, tshift, fseries=None):
"""Calls apply_fd_time_shift, and iFFTs to the time domain.
"""
start_time = self.time_series.start_time
tdshift = apply_fd_time_shift(fdsinx,
start_time + tshift,
fseries=fseries)
if not isinstance(tdshift, FrequencySeries):
# cast to FrequencySeries so time series will work
tdshift = FrequencySeries(tdshift,
delta_f=fdsinx.delta_f,
epoch=fdsinx.epoch)
return tdshift.to_timeseries()
def generate(self, *args):
"""Generates a waveform, applies a time shift and the detector response
function."""
self.current_params.update(dict(zip(self.variable_args, args)))
# FIXME: use the following when we switch to 2.7
#rfparams = {param: self.current_params[param]
# for param in self.rframe_generator.variable_args}
rfparams = dict([(param, self.current_params[param])
for param in self.rframe_generator.variable_args])
hp, hc = self.rframe_generator.generate_from_kwargs(**rfparams)
hp._epoch = hc._epoch = self._epoch
h = {}
if 'tc' in self.current_params:
try:
kmin = int(self.current_params['f_lower']/hp.delta_f)
except KeyError:
kmin = 0
if self.detector_names != ['RF']:
for detname, det in self.detectors.items():
# apply detector response function
fp, fc = det.antenna_pattern(self.current_params['ra'],
self.current_params['dec'],
self.current_params['polarization'],
self.current_params['tc'])
thish = fp*hp + fc*hc
# apply the time shift
tc = self.current_params['tc'] + \
det.time_delay_from_earth_center(self.current_params['ra'],
self.current_params['dec'],
self.current_params['tc'])
h[detname] = apply_fd_time_shift(thish, tc, kmin=kmin, copy=False)
else:
# no detector response, just use the + polarization
if 'tc' in self.current_params:
hp = apply_fd_time_shift(hp, self.current_params['tc'],
kmin=kmin, copy=False)
h['RF'] = hp
return h
def generate(self, **kwargs):
"""Generates and returns a waveform decompsed into separate modes.
Returns
-------
dict :
Dictionary of ``detector names -> modes -> (ulm, vlm)``, where
``ulm, vlm`` are the frequency-domain representations of the real
and imaginary parts, respectively, of the complex time series
representation of the ``hlm``.
"""
self.current_params.update(kwargs)
rfparams = {param: self.current_params[param]
for param in kwargs if param not in self.location_args}
hlms = self.rframe_generator.generate(**rfparams)
h = {det: {} for det in self.detectors}
for mode in hlms:
ulm, vlm = hlms[mode]
if isinstance(ulm, TimeSeries):
df = self.current_params['delta_f']
ulm = ulm.to_frequencyseries(delta_f=df)
vlm = vlm.to_frequencyseries(delta_f=df)
# time-domain waveforms will not be shifted so that the peak
# amplitude happens at the end of the time series (as they are
# for f-domain), so we add an additional shift to account for
# it
tshift = 1./df - abs(ulm._epoch)
else:
tshift = 0.
ulm._epoch = vlm._epoch = self._epoch
if self.detector_names != ['RF']:
for detname, det in self.detectors.items():
# apply the time shift
tc = self.current_params['tc'] + \
det.time_delay_from_earth_center(
self.current_params['ra'],
self.current_params['dec'],
self.current_params['tc'])
detulm = apply_fd_time_shift(ulm, tc+tshift, copy=True)
detvlm = apply_fd_time_shift(vlm, tc+tshift, copy=True)
if self.recalib:
# recalibrate with given calibration model
detulm = self.recalib[detname].map_to_adjust(
detulm, **self.current_params)
detvlm = self.recalib[detname].map_to_adjust(
detvlm, **self.current_params)
h[detname][mode] = (detulm, detvlm)
else:
# no detector response, just apply time shift
if 'tc' in self.current_params:
ulm = apply_fd_time_shift(ulm,
self.current_params['tc']+tshift,
copy=False)
vlm = apply_fd_time_shift(vlm,
self.current_params['tc']+tshift,
copy=False)
h['RF'][mode] = (ulm, vlm)
if self.gates is not None:
# resize all to nearest power of 2
ulms = {}
vlms = {}
for det in h:
ulm, vlm = h[det][mode]
ulm.resize(ceilpow2(len(ulm)-1) + 1)
vlm.resize(ceilpow2(len(vlm)-1) + 1)
ulms[det] = ulm
vlms[det] = vlm
ulms = strain.apply_gates_to_fd(ulms, self.gates)
vlms = strain.apply_gates_to_fd(ulms, self.gates)
for det in ulms:
h[det][mode] = (ulms[det], vlms[det])
return h
def generate(self, **kwargs):
"""Generates a waveform polarizations and applies a time shift.
Returns
-------
dict :
Dictionary of ``detector names -> (hp, hc)``, where ``hp, hc`` are
the plus and cross polarization, respectively.
"""
self.current_params.update(kwargs)
rfparams = {param: self.current_params[param]
for param in kwargs if param not in self.location_args}
hp, hc = self.rframe_generator.generate(**rfparams)
if isinstance(hp, TimeSeries):
df = self.current_params['delta_f']
hp = hp.to_frequencyseries(delta_f=df)
hc = hc.to_frequencyseries(delta_f=df)
# time-domain waveforms will not be shifted so that the peak amp
# happens at the end of the time series (as they are for f-domain),
# so we add an additional shift to account for it
tshift = 1./df - abs(hp._epoch)
else:
tshift = 0.
hp._epoch = hc._epoch = self._epoch
h = {}
if self.detector_names != ['RF']:
for detname, det in self.detectors.items():
# apply the time shift
tc = self.current_params['tc'] + \
det.time_delay_from_earth_center(self.current_params['ra'],
self.current_params['dec'], self.current_params['tc'])
dethp = apply_fd_time_shift(hp, tc+tshift, copy=True)
dethc = apply_fd_time_shift(hc, tc+tshift, copy=True)
if self.recalib:
# recalibrate with given calibration model
dethp = self.recalib[detname].map_to_adjust(
dethp, **self.current_params)
dethc = self.recalib[detname].map_to_adjust(
dethc, **self.current_params)
h[detname] = (dethp, dethc)
else:
# no detector response, just use the + polarization
if 'tc' in self.current_params:
hp = apply_fd_time_shift(hp, self.current_params['tc']+tshift,
copy=False)
hc = apply_fd_time_shift(hc, self.current_params['tc']+tshift,
copy=False)
h['RF'] = (hp, hc)
if self.gates is not None:
# resize all to nearest power of 2
hps = {}
hcs = {}
for det in h:
hp = h[det]
hc = h[det]
hp.resize(ceilpow2(len(hp)-1) + 1)
hc.resize(ceilpow2(len(hc)-1) + 1)
hps[det] = hp
hcs[det] = hc
hps = strain.apply_gates_to_fd(hps, self.gates)
hcs = strain.apply_gates_to_fd(hps, self.gates)
h = {det: (hps[det], hcs[det]) for det in h}
return h
