def make_strain_from_inj_object(self, inj, delta_t, detector_name, f_lower=None, distance_scale=1): """Make a h(t) strain time-series from an injection object as read from a sim_inspiral table, for example. Parameters ----------- inj : injection object The injection object to turn into a strain h(t). delta_t : float Sample rate to make injection at. 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, float}, optional Factor to scale the distance of an injection with. The default is no scaling. Returns -------- signal : float h(t) corresponding to the injection. """ detector = Detector(detector_name) if f_lower is None: f_l = inj.f_lower else: f_l = f_lower name, phase_order = legacy_approximant_name(inj.waveform) # compute the waveform time series hp, hc = get_td_waveform(inj, approximant=name, delta_t=delta_t, phase_order=phase_order, f_lower=f_l, distance=inj.distance, **self.extra_args) hp /= distance_scale hc /= distance_scale hp._epoch += inj.get_time_geocent() hc._epoch += inj.get_time_geocent() # taper the polarizations hp_tapered = wfutils.taper_timeseries(hp, inj.taper) hc_tapered = wfutils.taper_timeseries(hc, inj.taper) # compute the detector response and add it to the strain signal = detector.project_wave(hp_tapered, hc_tapered, inj.longitude, inj.latitude, inj.polarization) return signal
def make_strain_from_inj_object(self, inj, delta_t, detector_name, f_lower=None, distance_scale=1): """Make a h(t) strain time-series from an injection object as read from a sim_inspiral table, for example. Parameters ----------- inj : injection object The injection object to turn into a strain h(t). delta_t : float Sample rate to make injection at. 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, float}, optional Factor to scale the distance of an injection with. The default is no scaling. Returns -------- signal : float h(t) corresponding to the injection. """ detector = Detector(detector_name) if f_lower is None: f_l = inj.f_lower else: f_l = f_lower name, phase_order = legacy_approximant_name(inj.waveform) # compute the waveform time series hp, hc = get_td_waveform( inj, approximant=name, delta_t=delta_t, phase_order=phase_order, f_lower=f_l, distance=inj.distance, **self.extra_args ) hp /= distance_scale hc /= distance_scale hp._epoch += inj.get_time_geocent() hc._epoch += inj.get_time_geocent() # taper the polarizations hp_tapered = wfutils.taper_timeseries(hp, inj.taper) hc_tapered = wfutils.taper_timeseries(hc, inj.taper) # compute the detector response and add it to the strain signal = detector.project_wave(hp_tapered, hc_tapered, inj.longitude, inj.latitude, inj.polarization) return signal
def _postgenerate(self, res): """Applies a taper if it is in current params. """ hp, hc = res try: hp = taper_timeseries(hp, tapermethod=self.current_params['taper']) hc = taper_timeseries(hc, tapermethod=self.current_params['taper']) except KeyError: pass return hp, hc
def make_strain_from_inj_object(self, inj, delta_t, detector_name, f_lower=None, distance_scale=1): """Make a h(t) strain time-series from an injection object. Parameters ----------- inj : injection object The injection object to turn into a strain h(t). Can be any object which has waveform parameters as attributes, such as an element in a ``WaveformArray``. delta_t : float Sample rate to make injection at. 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, float}, optional Factor to scale the distance of an injection with. The default is no scaling. Returns -------- signal : float h(t) corresponding to the injection. """ detector = Detector(detector_name) if f_lower is None: f_l = inj.f_lower else: f_l = f_lower # compute the waveform time series hp, hc = get_td_waveform(inj, delta_t=delta_t, f_lower=f_l, **self.extra_args) hp /= distance_scale hc /= distance_scale hp._epoch += inj.tc hc._epoch += inj.tc # taper the polarizations try: hp_tapered = wfutils.taper_timeseries(hp, inj.taper) hc_tapered = wfutils.taper_timeseries(hc, inj.taper) except AttributeError: hp_tapered = hp hc_tapered = hc # compute the detector response and add it to the strain signal = detector.project_wave(hp_tapered, hc_tapered, inj.ra, inj.dec, inj.polarization) return signal
def _postgenerate(self, res): """Applies a taper if it is in current params. """ if 'taper' in self.current_params: tapermethod = self.current_params['taper'] for mode in res: ulm, vlm = res[mode] ulm = taper_timeseries(ulm, tapermethod=tapermethod) vlm = taper_timeseries(vlm, tapermethod=tapermethod) res[mode] = (ulm, vlm) return res
def get_wf_pols(file, mtotal, inclination=0.0, delta_t=1./1024, f_lower=30, distance=100): """ Generate the NR_hdf5_pycbc waveform from the HDF5 file <file> with specified params """ f = h5py.File(file, 'r') # Metadata parameters: params = {} params['mtotal'] = mtotal params['eta'] = f.attrs['eta'] params['mass1'] = pnutils.mtotal_eta_to_mass1_mass2(params['mtotal'], params['eta'])[0] params['mass2'] = pnutils.mtotal_eta_to_mass1_mass2(params['mtotal'], params['eta'])[1] params['spin1x'] = f.attrs['spin1x'] params['spin1y'] = f.attrs['spin1y'] params['spin1z'] = f.attrs['spin1z'] params['spin2x'] = f.attrs['spin2x'] params['spin2y'] = f.attrs['spin2y'] params['spin2z'] = f.attrs['spin2z'] params['coa_phase'] = f.attrs['coa_phase'] f.close() hp, hc = get_td_waveform(approximant='NR_hdf5_pycbc', numrel_data=file, mass1=params['mass1'], mass2=params['mass2'], spin1x=params['spin1x'], spin1y=params['spin1y'], spin1z=params['spin1z'], spin2x=params['spin2x'], spin2y=params['spin2y'], spin2z=params['spin2z'], delta_t=delta_t, f_lower=f_lower, inclination=inclination, coa_phase=params['coa_phase'], distance=distance) hp_tapered = wfutils.taper_timeseries(hp, 'TAPER_START') hc_tapered = wfutils.taper_timeseries(hc, 'TAPER_START') return hp_tapered, hc_tapered
def projector(detector_name, inj, hp, hc, distance_scale=1): """ Use the injection row to project the polarizations into the detector frame """ detector = Detector(detector_name) hp /= distance_scale hc /= distance_scale try: tc = inj.tc ra = inj.ra dec = inj.dec except: tc = inj.get_time_geocent() ra = inj.longitude dec = inj.latitude hp.start_time += tc hc.start_time += tc # taper the polarizations try: hp_tapered = wfutils.taper_timeseries(hp, inj.taper) hc_tapered = wfutils.taper_timeseries(hc, inj.taper) except AttributeError: hp_tapered = hp hc_tapered = hc projection_method = 'lal' if hasattr(inj, 'detector_projection_method'): projection_method = inj.detector_projection_method logging.info('Injecting at %s, method is %s', tc, projection_method) # compute the detector response and add it to the strain signal = detector.project_wave( hp_tapered, hc_tapered, ra, dec, inj.polarization, method=projection_method, reference_time=tc, ) return signal
def get_waveform_filter(out, template=None, **kwargs): """Return a frequency domain waveform filter for the specified approximant """ n = len(out) input_params = props(template, **kwargs) if input_params['approximant'] in filter_approximants(_scheme.mgr.state): wav_gen = filter_wav[type(_scheme.mgr.state)] htilde = wav_gen[input_params['approximant']](out=out, **input_params) htilde.resize(n) htilde.chirp_length = get_waveform_filter_length_in_time( **input_params) htilde.length_in_time = htilde.chirp_length return htilde if input_params['approximant'] in fd_approximants(_scheme.mgr.state): wav_gen = fd_wav[type(_scheme.mgr.state)] hp, hc = wav_gen[input_params['approximant']](**input_params) hp.resize(n) out[0:len(hp)] = hp[:] hp = FrequencySeries(out, delta_f=hp.delta_f, copy=False) hp.chirp_length = get_waveform_filter_length_in_time(**input_params) hp.length_in_time = hp.chirp_length return hp elif input_params['approximant'] in td_approximants(_scheme.mgr.state): # N: number of time samples required N = (n - 1) * 2 delta_f = 1.0 / (N * input_params['delta_t']) wav_gen = td_wav[type(_scheme.mgr.state)] hp, hc = wav_gen[input_params['approximant']](**input_params) # taper the time series hp if required if ('taper' in input_params.keys() and \ input_params['taper'] is not None): hp = wfutils.taper_timeseries(hp, input_params['taper'], return_lal=False) # total duration of the waveform tmplt_length = len(hp) * hp.delta_t # for IMR templates the zero of time is at max amplitude (merger) # thus the start time is minus the duration of the template from # lower frequency cutoff to merger, i.e. minus the 'chirp time' tChirp = -float(hp.start_time) # conversion from LIGOTimeGPS hp.resize(N) k_zero = int(hp.start_time / hp.delta_t) hp.roll(k_zero) htilde = FrequencySeries(out, delta_f=delta_f, copy=False) fft(hp.astype(real_same_precision_as(htilde)), htilde) htilde.length_in_time = tmplt_length htilde.chirp_length = tChirp return htilde else: raise ValueError("Approximant %s not available" % (input_params['approximant']))
def get_waveform_filter(out, template=None, **kwargs): """Return a frequency domain waveform filter for the specified approximant """ n = len(out) input_params = props(template, **kwargs) if input_params['approximant'] in filter_approximants(_scheme.mgr.state): wav_gen = filter_wav[type(_scheme.mgr.state)] htilde = wav_gen[input_params['approximant']](out=out, **input_params) htilde.resize(n) htilde.chirp_length = get_waveform_filter_length_in_time(**input_params) htilde.length_in_time = htilde.chirp_length return htilde if input_params['approximant'] in fd_approximants(_scheme.mgr.state): wav_gen = fd_wav[type(_scheme.mgr.state)] hp, hc = wav_gen[input_params['approximant']](**input_params) hp.resize(n) out[0:len(hp)] = hp[:] hp = FrequencySeries(out, delta_f=hp.delta_f, copy=False) hp.chirp_length = get_waveform_filter_length_in_time(**input_params) hp.length_in_time = hp.chirp_length return hp elif input_params['approximant'] in td_approximants(_scheme.mgr.state): # N: number of time samples required N = (n-1)*2 delta_f = 1.0 / (N * input_params['delta_t']) wav_gen = td_wav[type(_scheme.mgr.state)] hp, hc = wav_gen[input_params['approximant']](**input_params) # taper the time series hp if required if ('taper' in input_params.keys() and \ input_params['taper'] is not None): hp = wfutils.taper_timeseries(hp, input_params['taper'], return_lal=False) # total duration of the waveform tmplt_length = len(hp) * hp.delta_t # for IMR templates the zero of time is at max amplitude (merger) # thus the start time is minus the duration of the template from # lower frequency cutoff to merger, i.e. minus the 'chirp time' tChirp = - float( hp.start_time ) # conversion from LIGOTimeGPS hp.resize(N) k_zero = int(hp.start_time / hp.delta_t) hp.roll(k_zero) htilde = FrequencySeries(out, delta_f=delta_f, copy=False) fft(hp.astype(real_same_precision_as(htilde)), htilde) htilde.length_in_time = tmplt_length htilde.chirp_length = tChirp return htilde else: raise ValueError("Approximant %s not available" % (input_params['approximant']))
def get_waveform_filter(out, template=None, **kwargs): """Return a frequency domain waveform filter for the specified approximant """ n = len(out) input_params = props(template, **kwargs) if input_params['approximant'] in filter_approximants(_scheme.mgr.state): wav_gen = filter_wav[type(_scheme.mgr.state)] htilde = wav_gen[input_params['approximant']](out=out, **input_params) htilde.resize(n) htilde.chirp_length = get_waveform_filter_length_in_time( **input_params) htilde.length_in_time = htilde.chirp_length return htilde if input_params['approximant'] in fd_approximants(_scheme.mgr.state): wav_gen = fd_wav[type(_scheme.mgr.state)] duration = get_waveform_filter_length_in_time(**input_params) hp, hc = wav_gen[input_params['approximant']](duration=duration, return_hc=False, **input_params) hp.resize(n) out[0:len(hp)] = hp[:] hp = FrequencySeries(out, delta_f=hp.delta_f, copy=False) hp.length_in_time = hp.chirp_length = duration return hp elif input_params['approximant'] in td_approximants(_scheme.mgr.state): # N: number of time samples required N = (n - 1) * 2 delta_f = 1.0 / (N * input_params['delta_t']) wav_gen = td_wav[type(_scheme.mgr.state)] hp, hc = wav_gen[input_params['approximant']](**input_params) # taper the time series hp if required if ('taper' in input_params.keys() and \ input_params['taper'] is not None): hp = wfutils.taper_timeseries(hp, input_params['taper'], return_lal=False) return td_waveform_to_fd_waveform(hp, out=out) else: raise ValueError("Approximant %s not available" % (input_params['approximant']))
def get_waveform_filter(out, template=None, **kwargs): """Return a frequency domain waveform filter for the specified approximant """ n = len(out) input_params = props(template, **kwargs) if input_params['approximant'] in filter_approximants(_scheme.mgr.state): wav_gen = filter_wav[type(_scheme.mgr.state)] htilde = wav_gen[input_params['approximant']](out=out, **input_params) htilde.resize(n) htilde.chirp_length = get_waveform_filter_length_in_time(**input_params) htilde.length_in_time = htilde.chirp_length return htilde if input_params['approximant'] in fd_approximants(_scheme.mgr.state): wav_gen = fd_wav[type(_scheme.mgr.state)] duration = get_waveform_filter_length_in_time(**input_params) hp, hc = wav_gen[input_params['approximant']](duration=duration, return_hc=False, **input_params) hp.resize(n) out[0:len(hp)] = hp[:] hp = FrequencySeries(out, delta_f=hp.delta_f, copy=False) hp.length_in_time = hp.chirp_length = duration return hp elif input_params['approximant'] in td_approximants(_scheme.mgr.state): # N: number of time samples required N = (n-1)*2 delta_f = 1.0 / (N * input_params['delta_t']) wav_gen = td_wav[type(_scheme.mgr.state)] hp, hc = wav_gen[input_params['approximant']](**input_params) # taper the time series hp if required if ('taper' in input_params.keys() and \ input_params['taper'] is not None): hp = wfutils.taper_timeseries(hp, input_params['taper'], return_lal=False) return td_waveform_to_fd_waveform(hp, out=out) else: raise ValueError("Approximant %s not available" % (input_params['approximant']))
def make_strain_from_inj_object(self, inj, delta_t, detector_name, f_lower=None, distance_scale=1): """Make a h(t) strain time-series from an injection object as read from a sim_inspiral table, for example. Parameters ----------- inj : injection object The injection object to turn into a strain h(t). delta_t : float Sample rate to make injection at. 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, float}, optional Factor to scale the distance of an injection with. The default is no scaling. Returns -------- signal : float h(t) corresponding to the injection. """ detector = Detector(detector_name) if f_lower is None: f_l = inj.f_lower else: f_l = f_lower # FIXME: Old NR interface will soon be removed. Do not use! if inj.numrel_data != None and inj.numrel_data != "": # performing NR waveform injection # reading Hp and Hc from the frame files swigrow = self.getswigrow(inj) import lalinspiral Hp, Hc = lalinspiral.NRInjectionFromSimInspiral(swigrow, delta_t) # converting to pycbc timeseries 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 /= distance_scale hc /= distance_scale else: name, phase_order = legacy_approximant_name(inj.waveform) # compute the waveform time series hp, hc = get_td_waveform( inj, approximant=name, delta_t=delta_t, phase_order=phase_order, f_lower=f_l, distance=inj.distance, **self.extra_args) hp /= distance_scale hc /= distance_scale hp._epoch += inj.get_time_geocent() hc._epoch += inj.get_time_geocent() # taper the polarizations hp_tapered = wfutils.taper_timeseries(hp, inj.taper) hc_tapered = wfutils.taper_timeseries(hc, inj.taper) # compute the detector response and add it to the strain signal = detector.project_wave(hp_tapered, hc_tapered, inj.longitude, inj.latitude, inj.polarization) return signal
def get_two_pol_waveform_filter(outplus, outcross, template, **kwargs): """Return a frequency domain waveform filter for the specified approximant. Unlike get_waveform_filter this function returns both h_plus and h_cross components of the waveform, which are needed for searches where h_plus and h_cross are not related by a simple phase shift. """ n = len(outplus) # If we don't have an inclination column alpha3 might be used if not hasattr(template, 'inclination') and 'inclination' not in kwargs: if hasattr(template, 'alpha3'): kwargs['inclination'] = template.alpha3 input_params = props(template, **kwargs) if input_params['approximant'] in fd_approximants(_scheme.mgr.state): wav_gen = fd_wav[type(_scheme.mgr.state)] hp, hc = wav_gen[input_params['approximant']](**input_params) hp.resize(n) hc.resize(n) outplus[0:len(hp)] = hp[:] hp = FrequencySeries(outplus, delta_f=hp.delta_f, copy=False) outcross[0:len(hc)] = hc[:] hc = FrequencySeries(outcross, delta_f=hc.delta_f, copy=False) hp.chirp_length = get_waveform_filter_length_in_time(**input_params) hp.length_in_time = hp.chirp_length hc.chirp_length = hp.chirp_length hc.length_in_time = hp.length_in_time return hp, hc elif input_params['approximant'] in td_approximants(_scheme.mgr.state): # N: number of time samples required N = (n-1)*2 delta_f = 1.0 / (N * input_params['delta_t']) wav_gen = td_wav[type(_scheme.mgr.state)] hp, hc = wav_gen[input_params['approximant']](**input_params) # taper the time series hp if required if 'taper' in input_params.keys() and \ input_params['taper'] is not None: hp = wfutils.taper_timeseries(hp, input_params['taper'], return_lal=False) hc = wfutils.taper_timeseries(hc, input_params['taper'], return_lal=False) # total duration of the waveform tmplt_length = len(hp) * hp.delta_t # for IMR templates the zero of time is at max amplitude (merger) # thus the start time is minus the duration of the template from # lower frequency cutoff to merger, i.e. minus the 'chirp time' tChirp = - float( hp.start_time ) # conversion from LIGOTimeGPS hp.resize(N) hc.resize(N) k_zero = int(hp.start_time / hp.delta_t) hp.roll(k_zero) hc.roll(k_zero) hp_tilde = FrequencySeries(outplus, delta_f=delta_f, copy=False) hc_tilde = FrequencySeries(outcross, delta_f=delta_f, copy=False) fft(hp.astype(real_same_precision_as(hp_tilde)), hp_tilde) fft(hc.astype(real_same_precision_as(hc_tilde)), hc_tilde) hp_tilde.length_in_time = tmplt_length hp_tilde.chirp_length = tChirp hc_tilde.length_in_time = tmplt_length hc_tilde.chirp_length = tChirp return hp_tilde, hc_tilde else: raise ValueError("Approximant %s not available" % (input_params['approximant']))
# APPROXIMANT hplus_approx, hcross_approx = get_td_waveform(approximant=approx, distance=distance, mass1=mass1, mass2=mass2, spin1x=0.0, spin2x=0.0, spin1y=0.0, spin2y=0.0, spin1z=simulations.simulations[sim_number]['spin1z'], spin2z=simulations.simulations[sim_number]['spin2z'], inclination=inc, f_lower=f_low_approx, delta_t=delta_t) hplus_approx = wfutils.taper_timeseries(hplus_approx, 'TAPER_START') hcross_approx = wfutils.taper_timeseries(hcross_approx, 'TAPER_START') # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # MATCH CALCULATION # Make the timeseries consistent lengths tlen = max([len(hplus_approx), len(hplus_NR), int(datalen/delta_t)]) #tlen = int(datalen / delta_t) hplus_approx.resize(tlen) hplus_NR.resize(tlen) hcross_approx.resize(tlen) hcross_NR.resize(tlen)
def apply(self, strain, detector_name, f_lower=None, distance_scale=1, simulation_ids=None): """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, float}, optional Factor to scale the distance of an injection with. The default is no scaling. simulation_ids: iterable, optional If given, only inject signals with the given simulation IDs. Returns ------- None Raises ------ TypeError For invalid types of `strain`. """ if not strain.dtype 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] injections = self.table if simulation_ids: injections = [inj for inj in injections \ if inj.simulation_id in simulation_ids] for inj in injections: if f_lower is None: f_l = inj.f_lower else: f_l = f_lower if inj.numrel_data != None and inj.numrel_data != "": # performing NR waveform injection # reading Hp and Hc from the frame files swigrow = self.getswigrow(inj) import lalinspiral Hp, Hc = lalinspiral.NRInjectionFromSimInspiral(swigrow, strain.delta_t) # converting to pycbc timeseries 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 /= distance_scale hc /= distance_scale end_time = float(hp.get_end_time()) start_time = float(hp.get_start_time()) if end_time < t0 or start_time > t1: continue else: # roughly estimate if the injection may overlap with the segment end_time = inj.get_time_geocent() inj_length = sim.SimInspiralTaylorLength( strain.delta_t, inj.mass1 * lal.MSUN_SI, inj.mass2 * lal.MSUN_SI, f_l, 0) start_time = end_time - 2 * inj_length if end_time < t0 or start_time > t1: continue name, phase_order = legacy_approximant_name(inj.waveform) # compute the waveform time series hp, hc = get_td_waveform( inj, approximant=name, delta_t=strain.delta_t, phase_order=phase_order, f_lower=f_l, distance=inj.distance * distance_scale, **self.extra_args) 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 signal = detector.project_wave( hp, hc, inj.longitude, inj.latitude, inj.polarization) # the taper_timeseries function converts to a LAL TimeSeries signal = signal.astype(strain.dtype) signal_lal = wfutils.taper_timeseries(signal, inj.taper, return_lal=True) add_injection(lalstrain, signal_lal, None) strain.data[:] = lalstrain.data.data[:]
# hcross_NR.data = window_wave(hcross_NR.data) dAmpbyAmp = scale_NR(times_codeunits, dAmpbyAmp_codeunits, mass, delta_t=delta_t) dphi = scale_NR(times_codeunits, dphi_codeunits, mass, delta_t=delta_t) NR_freqs = wfutils.frequency_from_polarizations(hplus_NR, hcross_NR) # zero-out everything after ffinal # crossing_point = \ # NR_freqs.sample_times[ # np.isclose(NR_freqs,ffinal,1/hplus_NR.sample_times[-1])[0] # ] # hplus_NR.data[int(hplus_NR.sample_times>crossing_point)] = 0.0 # hcross_NR.data[int(hcross_NR.sample_times>crossing_point)] = 0.0 # hplus_NR = wfutils.taper_timeseries(hplus_NR, "TAPER_STARTEND") hcross_NR = wfutils.taper_timeseries(hcross_NR, "TAPER_STARTEND") # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # APPROXIMANT # if approx == 'SEOBNRv2': if approx in td_approximants(): hplus_approx, hcross_approx = get_td_waveform( approximant=approx, distance=distance, mass1=mass1, mass2=mass2, spin1x=0.0, spin2x=0.0,
def make_strain_from_inj_object(self, inj, delta_t, detector_name, f_lower=None, distance_scale=1): """Make a h(t) strain time-series from an injection object as read from a sim_inspiral table, for example. Parameters ----------- inj : injection object The injection object to turn into a strain h(t). delta_t : float Sample rate to make injection at. 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, float}, optional Factor to scale the distance of an injection with. The default is no scaling. Returns -------- signal : float h(t) corresponding to the injection. """ detector = Detector(detector_name) if f_lower is None: f_l = inj.f_lower else: f_l = f_lower # FIXME: Old NR interface will soon be removed. Do not use! if inj.numrel_data != None and inj.numrel_data != "": # performing NR waveform injection # reading Hp and Hc from the frame files swigrow = self.getswigrow(inj) import lalinspiral Hp, Hc = lalinspiral.NRInjectionFromSimInspiral(swigrow, delta_t) # converting to pycbc timeseries 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 /= distance_scale hc /= distance_scale else: name, phase_order = legacy_approximant_name(inj.waveform) # compute the waveform time series hp, hc = get_td_waveform(inj, approximant=name, delta_t=delta_t, phase_order=phase_order, f_lower=f_l, distance=inj.distance, **self.extra_args) hp /= distance_scale hc /= distance_scale hp._epoch += inj.get_time_geocent() hc._epoch += inj.get_time_geocent() # taper the polarizations hp_tapered = wfutils.taper_timeseries(hp, inj.taper) hc_tapered = wfutils.taper_timeseries(hc, inj.taper) # compute the detector response and add it to the strain signal = detector.project_wave(hp_tapered, hc_tapered, inj.longitude, inj.latitude, inj.polarization) return signal
def apply(self, strain, detector_name, f_lower=None, distance_scale=1, simulation_ids=None): """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, float}, optional Factor to scale the distance of an injection with. The default is no scaling. simulation_ids: iterable, optional If given, only inject signals with the given simulation IDs. Returns ------- None Raises ------ TypeError For invalid types of `strain`. """ if not strain.dtype 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] injections = self.table if simulation_ids: injections = [inj for inj in injections \ if inj.simulation_id in simulation_ids] for inj in injections: if f_lower is None: f_l = inj.f_lower else: f_l = f_lower if inj.numrel_data != None and inj.numrel_data != "": # performing NR waveform injection # reading Hp and Hc from the frame files swigrow = self.getswigrow(inj) import lalinspiral Hp, Hc = lalinspiral.NRInjectionFromSimInspiral(swigrow, strain.delta_t) # converting to pycbc timeseries 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 /= distance_scale hc /= distance_scale end_time = float(hp.get_end_time()) start_time = float(hp.get_start_time()) if end_time < t0 or start_time > t1: continue else: # roughly estimate if the injection may overlap with the segment end_time = inj.get_time_geocent() inj_length = sim.SimInspiralTaylorLength( strain.delta_t, inj.mass1 * lal.MSUN_SI, inj.mass2 * lal.MSUN_SI, f_l, 0) start_time = end_time - 2 * inj_length if end_time < t0 or start_time > t1: continue name, phase_order = legacy_approximant_name(inj.waveform) # compute the waveform time series hp, hc = get_td_waveform( inj, approximant=name, delta_t=strain.delta_t, phase_order=phase_order, f_lower=f_l, distance=inj.distance * distance_scale, **self.extra_args) hp._epoch += float(end_time) hc._epoch += float(end_time) if float(hp.start_time) > t1: continue # taper the polarizations hp_tapered = wfutils.taper_timeseries(hp, inj.taper) hc_tapered = wfutils.taper_timeseries(hc, inj.taper) # compute the detector response and add it to the strain signal = detector.project_wave(hp_tapered, hc_tapered, inj.longitude, inj.latitude, inj.polarization) signal = signal.astype(strain.dtype) signal_lal = signal.lal() add_injection(lalstrain, signal_lal, None) strain.data[:] = lalstrain.data.data[:]
mass1=params['mass1'], mass2=params['mass2'], spin1x=params['spin1x'], spin1y=params['spin1y'], spin1z=params['spin1z'], spin2x=params['spin2x'], spin2y=params['spin2y'], spin2z=params['spin2z'], delta_t=deltaT, f_lower=f_lower, inclination=float(sys.argv[2]), coa_phase=params['coa_phase'], distance=100) hp_tapered = wfutils.taper_timeseries(hp, 'TAPER_START') hc_tapered = wfutils.taper_timeseries(hc, 'TAPER_START') hp_tapered.data[:] /= pycbc.filter.sigma(hp_tapered) hc_tapered.data[:] /= pycbc.filter.sigma(hc_tapered) now = timeit.time.time() print "took %f sec to extract pols"%(now-then) # Generate the signal in the detector detector = Detector(detector_name) #longitude=float(sys.argv[1]) #latitude=float(sys.argv[2]) polarization=float(sys.argv[3])
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 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[:]