def batch_project(
detector: Detector,
extrinsics: Union[np.recarray, Dict[str, np.ndarray]],
waveforms: np.ndarray,
static_args: Dict[str, Union[str,float]],
sample_frequencies: Optional[np.ndarray]=None,
distance_scale: bool=False,
time_shift: bool=False,
):
# get frequency bins (we handle numpy arrays rather than PyCBC arrays with .sample_frequencies attributes)
if sample_frequencies is None:
sample_frequencies = get_sample_frequencies(
f_final=static_args['f_final'],
delta_f=static_args['delta_f']
)
# check waveform matrix inputs
assert waveforms.shape[1] == 2, "2nd dim in waveforms must be plus and cross polarizations."
assert waveforms.shape[0] == len(extrinsics), "waveform batch and extrinsics length must match."
if distance_scale:
# scale waveform amplitude according to sample d_L parameter
scale = static_args.get('distance', 1000) / extrinsics['distance'] # default d_L = 1
waveforms = np.array(waveforms) * scale[:, None, None]
# calculate antenna pattern given arrays of extrinsic parameters
fp, fc = detector.antenna_pattern(
extrinsics['ra'], extrinsics['dec'], extrinsics['psi'],
static_args.get('ref_time', 0.)
)
# batch project
projections = fp[:, None]*waveforms[:, 0, :] + fc[:, None]*waveforms[:, 1, :]
# if distance_scale:
# # scale waveform amplitude according to sample d_L parameter
# scale = static_args.get('distance', 1000) / extrinsics['distance'] # default d_L = 1
# projections *= scale[:, None]
if time_shift:
assert waveforms.shape[-1] == sample_frequencies.shape[0], "delta_f and fd_length do not match."
# calculate geocentric time for the given detector
dt = detector.time_delay_from_earth_center(extrinsics['ra'], extrinsics['dec'], static_args.get('ref_time', 0.))
# Calculate time shift due to sampled t_c parameters
dt += extrinsics['time'] - static_args.get('ref_time', 0.) # default ref t_c = 0
dt = dt.astype(match_precision(sample_frequencies, real=True))
shift = np.exp(- 2j * np.pi * dt[:, None] * sample_frequencies[None, :])
projections *= shift
return projections
def project_onto_detector(
detector: Detector,
sample: Union[np.recarray, Dict[str, float]],
hp: Union[np.ndarray, FrequencySeries],
hc: Union[np.ndarray, FrequencySeries],
static_args: Dict[str, Union[str, float]],
sample_frequencies: Optional[np.ndarray]=None,
as_pycbc: bool=True,
time_shift: bool=False,
) -> Union[np.ndarray, FrequencySeries]:
"""Takes a plus and cross waveform polarization (i.e. generated by intrinsic parameters)
and projects them onto a specified interferometer using a PyCBC.detector.Detector.
"""
# input handling
assert type(hp) == type(hc), "Plus and cross waveform types must match."
if isinstance(hp, FrequencySeries):
assert np.all(hp.sample_frequencies == hc.sample_frequencies), "FrequencySeries.sample_frequencies do not match."
sample_frequencies = hp.sample_frequencies
assert sample_frequencies is not None, "Waveforms not FrequencySeries type or frequency series array not provided."
# project intrinsic waveform onto detector
fp, fc = detector.antenna_pattern(sample['ra'], sample['dec'], sample['psi'], static_args.get('ref_time', 0.))
h = fp*hp + fc*hc
# scale waveform amplitude according to ratio to reference distance
h *= static_args.get('distance', 1) / sample['distance'] # default d_L = 1
if time_shift:
# Calculate time shift at detector and add to geocentric time
dt = detector.time_delay_from_earth_center(sample['ra'], sample['dec'], static_args.get('ref_time', 0.))
dt += sample['time'] - static_args.get('ref_time', 0.) # default ref t_c = 0
dt = dt.astype(match_precision(sample_frequencies))
h *= np.exp(- 2j * np.pi * dt * sample_frequencies).astype(match_precision(h, real=False))
# output desired type
if isinstance(h, FrequencySeries):
if as_pycbc:
return h
else:
return h.data
else:
if as_pycbc:
return FrequencySeries(h, delta_f=static_args['delta_f'], copy=False)
else:
return h
# coding: utf-8
# In[4]:
from pycbc.detector import Detector
# In[5]:
det_h1 = Detector('H1')
det_l1 = Detector('L1')
det_v1 = Detector('V1')
# In[6]:
end_time = 1192529720
declination = 0.65
right_ascension = 4.67
polarization = 2.34
# In[7]:
det_h1.antenna_pattern(right_ascension, declination, polarization, end_time)
def get_td_waveform_resp(params):
"""
Generate time domain data of gw detector response
This function will produce data of a gw detector response based on a
numerical relativity waveform.
Parameters
----------
params: object
The fields of this object correspond to the kwargs of the
`pycbc.waveform.get_td_waveform()` method and the positional
arguments of `pycbc.detector.Detector.antenna_pattern()`. For the later
the fields should be supplied as `params.ra`, `.dec`, `.polarization`
and `.geocentric_end_time`
Returns
-------
h_plus: pycbc.Types.TimeSeries
h_cross: pycbc.Types.TimeSeries
pats: dictionary
Dictionary containing 'H1' and 'L1' keys. Each key maps to an object
of containing the field `.f_plus` and `.f_cross` corresponding to
the plus and cross antenna patterns for the two ifos 'H1' and 'L1'.
"""
# # construct waveform string that can be parsed by lalsimulation
waveform_string = params.approximant
if not pn_orders[params.order] == -1:
waveform_string += params.order
name, phase_order = legacy_approximant_name(waveform_string)
# Populate additional fields of params object
params.mchirp, params.eta = pnutils.mass1_mass2_to_mchirp_eta(
params.mass1, params.mass2)
params.waveform = waveform_string
params.approximant = name
params.phase_order = phase_order
# generate waveform
h_plus, h_cross = get_td_waveform(params)
# Generate antenna patterns for all ifos
pats = {}
for ifo in params.instruments:
# get Detector instance for IFO
det = Detector(ifo)
# get antenna pattern
f_plus, f_cross = det.antenna_pattern(
params.ra,
params.dec,
params.polarization,
params.geocentric_end_time)
# Populate antenna patterns with new pattern
pat = type('AntennaPattern', (object,), {})
pat.f_plus = f_plus
pat.f_cross = f_cross
pats[ifo] = pat
return h_plus, h_cross, pats
def load_inject_condition_ccsn(t_i,
t_f,
t_inj,
ra,
dec,
pol,
hp,
hc,
local=False,
Tc=16,
To=2,
fw=2048,
window='tukey',
detector='H',
qtrans=False,
qsplit=False,
dT=2.0,
save=False,
data_path=None):
"""Fucntion to load a chunk, inject a waveform and condition, created to enable parallelizing.
"""
vmem = psutil.virtual_memory()
free_mem = vmem.free >> 20
avail_mem = vmem.available >> 20
# if free_mem < 3e5:
if avail_mem < 3e5:
return
if local:
files = get_files(detector)
try:
data = TimeSeries.read(files,
start=t_i,
end=t_f,
format='hdf5.losc') # load data locally
except:
return
else:
# load data from losc
try:
data = TimeSeries.fetch_open_data(detector + '1',
*(t_i, t_f),
sample_rate=fw,
verbose=False,
cache=True)
except:
return
if np.isnan(data.value).any():
return
det_obj = Detector(detector + '1')
delay = det_obj.time_delay_from_detector(Detector('H1'), ra, dec, t_inj)
t_inj += delay
fp, fc = det_obj.antenna_pattern(ra, dec, pol, t_inj)
# wfs_path = Path(git_path + '/shared/ccsn_wfs/' + ccsn_paper)
# sim_data = [i.strip().split() for i in open(join(wfs_path, ccsn_file)).readlines()]
# if ccsn_paper == 'radice':
# line_s = 1
# else:
# line_s = 0
# D = D_kpc * 3.086e+21 # cm
# sim_times = np.asarray([float(dat[0]) for dat in sim_data[line_s:]])
# hp = np.asarray([float(dat[1]) for dat in sim_data[line_s:]]) / D
# if ccsn_paper == 'abdikamalov':
# hc = np.zeros(hp.shape)
# else:
# hc = np.asarray([float(dat[2]) for dat in sim_data[line_s:]]) / D
# dt = sim_times[1] - sim_times[0]
h = fp * hp + fc * hc
# h = TimeSeries(h, t0=sim_times[0], dt=dt)
# h = h.resample(rate=fw, ftype = 'iir', n=20) # downsample to working frequency fw
# h = h.highpass(frequency=11, filtfilt=True) # filter out frequencies below 20Hz
# inj_window = scisig.tukey(M=len(h), alpha=0.08, sym=True)
# h = h * inj_window
# h = h.pad(int((fw * Tc - len(h)) / 2))
wf_times = data.times.value
shift = int((t_inj - (wf_times[0] + Tc / 2)) * fw)
h = np.roll(h.value, shift)
h = TimeSeries(h, t0=wf_times[0], dt=data.dt)
try:
h = h.taper()
except:
pass
injected_data = data.inject(h)
del data
gc.collect()
cond_data = condition_data(injected_data, To, fw, window, qtrans, qsplit,
dT)
del injected_data
gc.collect()
x = []
times = []
for dat in cond_data:
x.append(dat.values)
times.append(dat.t0)
del cond_data
gc.collect()
x = np.asarray(x)
times = np.asarray(times)
idx = find_closest_index(t_inj, times)
x = x[idx]
times = times[idx]
return x, times
def load_inject_condition(t_i,
t_f,
t_inj,
ra,
dec,
pol,
alpha,
inj_type,
inj_params=None,
local=False,
Tc=16,
To=2,
fw=2048,
window='tukey',
detector='H',
qtrans=False,
qsplit=False,
dT=2.0,
hp=None,
save=False,
data_path=None):
"""Fucntion to load a chunk, inject a waveform and condition, created to enable parallelizing.
"""
vmem = psutil.virtual_memory()
free_mem = vmem.free >> 20
avail_mem = vmem.available >> 20
# if free_mem < 3e5:
if avail_mem < 3e5:
return
if local:
files = get_files(detector)
try:
data = TimeSeries.read(files,
start=t_i,
end=t_f,
format='hdf5.losc') # load data locally
except:
return
else:
# load data from losc
try:
data = TimeSeries.fetch_open_data(detector + '1',
*(t_i, t_f),
sample_rate=fw,
verbose=False,
cache=True)
except:
return
if np.isnan(data.value).any():
return
det_obj = Detector(detector + '1')
delay = det_obj.time_delay_from_detector(Detector('H1'), ra, dec, t_inj)
t_inj += delay
fp, fc = det_obj.antenna_pattern(ra, dec, pol, t_inj)
wf_times = data.times.value
hp, hc = gen_inject(wf_times, data.dt, t_inj, alpha, inj_type, inj_params,
Tc, fw)
h = fp * hp + fc * hc
injected_data = data.inject(h)
del data
gc.collect()
cond_data = condition_data(injected_data, To, fw, window, qtrans, qsplit,
dT)
del injected_data
gc.collect()
x = []
times = []
for dat in cond_data:
x.append(dat.values)
times.append(dat.t0)
del cond_data
gc.collect()
x = np.asarray(x)
times = np.asarray(times)
idx = find_closest_index(t_inj, times)
x = x[idx]
times = times[idx]
return x, times
from pycbc.detector import Detector
from pycbc.waveform import get_td_waveform
# Time, orientation and location of the source in the sky
ra = 1.7
dec = 1.7
pol = 0.2
inc = 0
time = 1000000000
# We can calcualate the antenna pattern for Hanford at
# the specific sky location
d = Detector("H1")
# We get back the fp and fc antenna pattern weights.
fp, fc = d.antenna_pattern(ra, dec, pol, time)
print("fp={}, fc={}".format(fp, fc))
# These factors allow us to project a signal into what the detector would
# observe
## Generate a waveform
hp, hc = get_td_waveform(approximant="IMRPhenomD", mass1=10, mass2=10,
f_lower=30, delta_t=1.0/4096, inclination=inc,
distance=400)
## Apply the factors to get the detector frame strain
ht = fp * hp + fc * hc
# The projection process can also take into account the rotation of the
def load_inject_condition_ccsn_multi_scale(t_i,
t_f,
t_inj,
ra,
dec,
pol,
hp,
hc,
local=False,
Tc=16,
To=2,
fw=2048,
window='tukey',
detector='H',
input_shape=(299, 299),
scales=[0.5, 1.0, 2.0],
frange=(10, 2048),
qrange=(4, 100),
save=False,
data_path=None):
"""Fucntion to load a chunk, inject a waveform and condition, created to enable parallelizing.
"""
vmem = psutil.virtual_memory()
free_mem = vmem.free >> 20
avail_mem = vmem.available >> 20
# if free_mem < 3e5:
if avail_mem < 3e5:
return
if local:
files = get_files(detector)
try:
data = TimeSeries.read(files,
start=t_i,
end=t_f,
format='hdf5.losc') # load data locally
except:
return
else:
# load data from losc
try:
data = TimeSeries.fetch_open_data(detector + '1',
*(t_i, t_f),
sample_rate=fw,
verbose=False,
cache=True)
except:
return
if np.isnan(data.value).any():
return
det_obj = Detector(detector + '1')
delay = det_obj.time_delay_from_detector(Detector('H1'), ra, dec, t_inj)
t_inj += delay
fp, fc = det_obj.antenna_pattern(ra, dec, pol, t_inj)
h = fp * hp + fc * hc
wf_times = data.times.value
shift = int((t_inj - (wf_times[0] + Tc / 2)) * fw)
h = np.roll(h.value, shift)
h = TimeSeries(h, t0=wf_times[0], dt=data.dt)
try:
h = h.taper()
except:
pass
injected_data = data.inject(h)
del data
gc.collect()
# cond_data = condition_data(injected_data, To, fw, window, qtrans, qsplit, dT)
cond_data = condition_data(injected_data, To, fw, window, qtrans=False)
del injected_data
gc.collect()
# x = []
# times = []
# for dat in cond_data:
# x.append(dat.values)
# times.append(dat.t0)
x, times = qsplit_multi_scale(cond_data,
t_i,
t_f,
To=To,
frange=frange,
qrange=qrange,
input_shape=input_shape,
scales=scales)
del cond_data
gc.collect()
x = np.asarray(x)
times = np.asarray(times)
# idx = find_closest_index(t_inj, times)
idx = find_closest_index(t_inj, times - min(scales) / 2)
x = x[idx]
times = times[idx]
return x, times
