def simulated_signals(noise): global next_val,signal_gw apx=['TaylorT1','TaylorT2','EOBNRv2','SEOBNRv1','SEOBNRv2'] with open('gdrive/My Drive/GW data/labels_5_noise.csv', 'a', newline='') as file: for a in tqdm(range(len(apx))): check=np.zeros(noise.shape[1]) k=0 for m1 in range(5,16,5): for m2 in range(5,16,5): for d in range(50,501,100): for fl in [60,120]: if (m1+m2+d+fl) not in check: check[k]=m1+m2+d+fl hp,hc = get_td_waveform(approximant=apx[a], mass1=m1,mass2=m2, delta_t=1.0/4096, f_lower=fl,f_final=50, distance=d) if len(hp)<=noise.shape[1]: signal_gw[next_val:next_val+noise.shape[0],:]=np.copy(noise) pos=np.random.randint(0,noise.shape[1]-len(hp)) signal_gw[next_val:next_val+noise.shape[0],pos:pos+len(hp)]+=hp writer = csv.writer(file) for i in range(noise.shape[0]): col=np.zeros(27) col[m1//5-1],col[2+m2//4],col[5+d//50],col[10+fl//60],col[13],col[26]=1,1,1,1,1,1 writer.writerow(col) k=k+1 next_val+=(noise.shape[0])
def generate_signal(param_set): hp, hc = get_td_waveform( approximant= 'SEOBNRv4', #This approximant is only appropriate for BBH mergers mass1=param_set['m1'], mass2=param_set['m2'], spin1z=param_set['x1'], spin2z=param_set['x2'], inclination_range=param_set['inc'], coa_phase=param_set['coa'], distance=param_set['dist'], delta_t=1.0 / param_set['f'], f_lower=30) time = 100000000 det_h1 = Detector('H1') det_l1 = Detector('L1') det_v1 = Detector('V1') hp = fade_on(hp, 0.25) hc = fade_on(hc, 0.25) sig_h1 = det_h1.project_wave(hp, hc, param_set['ra'], param_set['dec'], param_set['pol']) sig_l1 = det_l1.project_wave(hp, hc, param_set['ra'], param_set['dec'], param_set['pol']) sig_v1 = det_v1.project_wave(hp, hc, param_set['ra'], param_set['dec'], param_set['pol']) return {'H1': sig_h1, 'L1': sig_l1, 'V1': sig_v1}
def get_cbc(f_lower, delta_t, mass1=38.9, mass2=32.8): filename = 'waveforms/cbc_%.1f_%.1f.dat' % (mass1, mass2) if not os.path.isfile(filename): try: from pycbc.waveform import get_td_waveform except: print("Waveform not found and no pycbc installed...") exit(0) hp, hc = get_td_waveform(approximant="SEOBNRv2", mass1=mass1, mass2=mass2, f_lower=f_lower, delta_t=delta_t, distance=1) tt = hp.sample_times t0 = tt[0] f = open(filename, "w+") for i in xrange(len(tt)): f.write("%.15e %.15e %.15e\n" % (tt[i] - t0, hp[i], hc[i])) f.close() data_out = np.loadtxt(filename) tt, hp, hc = data_out[:, 0], data_out[:, 1], data_out[:, 2] dt = tt[1] - tt[0] if dt != delta_t: raise ValueError("Waveform delta t (%.0f) different from " "requested(%.0f)" % (dt, delta_t)) return tt, hp, hc
def create_dataset(filename, samples): file = h5py.File(filename, "w") for i in range(samples): print(i) m1, m2, SNR, merger_time = GWsynthesizer.sample() hp, hc = get_td_waveform(approximant='SEOBNRv4_opt', mass1=m1, mass2=m2, delta_t=delta_t, f_lower=25, distance=100) noise = generate_noise(time_duration, delta_f, delta_t, f_min) scaled_template, amplitude = GWsynthesizer.scale(hp, noise, SNR) injected_waveform = GWsynthesizer.inject(merger_time, noise, scaled_template) injected_waveform = np.array(injected_waveform) dset = file.create_dataset('sample_' + str(i), data=injected_waveform) dset.attrs['m1'] = m1 dset.attrs['m2'] = m2 dset.attrs['SNR'] = SNR dset.attrs['amplitude'] = amplitude dset.attrs['merger_time'] = merger_time return file
def gen_pycbc_waveform(mass1, mass2, approximant, delta_t=1./8192, f_lower=30, distance=1, t1=None, t2=None, *args, **kwargs): q = mass1/mass2 mtot = mass1 + mass2 hp, hc = waveform.get_td_waveform(approximant=approximant, mass1=mass1, mass2=mass2, delta_t=delta_t, f_lower=f_lower, distance=distance) times = phenom.StoM(hp.sample_times.numpy(), mtot) ylm = np.abs(lal.SpinWeightedSphericalHarmonic(0,0,-2,2,2)) amp_scale = utils.td_amp_scale(mtot, distance) * ylm hp_array = hp.numpy() / amp_scale hc_array = hc.numpy() / amp_scale h_array = hp_array - 1.j*hc_array if t1 is None: t1 = times[0] if t2 is None: t2 = times[-1] mask = (times >= t1) & (times <= t2) times = times[mask] h_array = h_array[mask] return times, h_array
def generate_TD_waveform(mass_rat, eccentricity, s1z, s2z, approximant='TaylorT1', total_m=50, f_lower=20., delta_t=1. / 1024): nonspinning_models = [ 'TaylorT1', 'TaylorT2', 'TaylorEt', 'TaylorT3', 'TaylorT4', 'EOBNRv2', 'EOBNRv2HM', 'EOBNRv2_ROM', 'EOBNRv2HM_ROM', 'SEOBNRv1', 'SEOBNRv1_ROM_DoubleSpin', 'SEOBNRv1_ROM_EffectiveSpin', 'TEOBResum_ROM', 'PhenSpinTaylor', 'PhenSpinTaylorRD', 'IMRPhenomA', 'EccentricTD', 'NRSur7dq2' ] if approximant in nonspinning_models: s1z = 0 s2z = 0 mass1, mass2 = q_to_masses(mass_rat, total_m) hp, hc = hp, hc = get_td_waveform(mass1=mass1, mass2=mass2, spin1z=s1z, spin2z=s2z, delta_t=delta_t, f_lower=f_lower, approximant=approximant, eccentricity=eccentricity) hs = hp + hc * 1j amp = abs(hs) phase = np.unwrap(np.angle(hs)) return hp.sample_times.data, np.real(hp.data), np.real(hc.data), np.imag( hp.data), np.imag(hc.data), amp, phase
def GetFittingFactor(comp_mass1, comp_mass2, waveform0, tp_apx, tp_m1, tp_m2, tp_ecc, tp_lan, tp_inc, radius, f_low=30): waveform0_mchirp = pycbc.conversions.mchirp_from_mass1_mass2(comp_mass1, comp_mass2) matches = [] for k in range(0, len(tp_m1)): template_m1 = tp_m1[k] template_m2 = tp_m2[k] template_mchirp = pycbc.conversions.mchirp_from_mass1_mass2(template_m1, template_m2) diff = abs(waveform0_mchirp - template_mchirp) percentage_diff = diff/waveform0_mchirp if (percentage_diff > radius): matches.append(0.) else: hp, hc = get_td_waveform(approximant = 'EccentricTD', mass1 = tp_m1[k], mass2 = tp_m2[k], eccentricity = tp_ecc[k], long_asc_nodes = tp_lan[k], inclination = tp_inc[k], f_lower = f_low, delta_t = waveform0.delta_t) this_match = GetMatch(waveform0, hp) matches.append(this_match) print ('Found a nontrivial match: at template %d: %s' % (k, this_match)) matches = np.asarray(matches) fitting_factor = np.amax(matches) return fitting_factor
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 generate_waveform(static_arguments, waveform_params): if static_arguments["approximant"] not in td_approximants(): print("Invalid waveform approximant. Please input" "a valid PyCBC time-series approximant.") quit() sample_length = int(static_arguments["sample_length"] * static_arguments["target_sampling_rate"]) # Collect all the required parameters for the simulation from the given # static and variable parameters simulation_parameters = dict(approximant=static_arguments['approximant'], coa_phase=waveform_params['coa_phase'], delta_f=static_arguments['delta_f'], delta_t=static_arguments['delta_t'], distance=static_arguments['distance'], f_lower=static_arguments['f_lower'], inclination=waveform_params['inclination'], mass1=waveform_params['mass1'], mass2=waveform_params['mass2'], spin1z=waveform_params['spin1z'], spin2z=waveform_params['spin2z'], ra=waveform_params['ra'], dec=waveform_params['dec']) # Perform the actual simulation with the given parameters h_plus, h_cross = get_td_waveform(**simulation_parameters) start_time = np.copy(float(h_plus.start_time)) return h_plus, simulation_parameters, h_plus.sample_times, start_time
def generate_data(batch_size, sample_rate, mass_range): ''' Function for generating synthetic gravitational waveforms for binary mergers of equal masses over a range of masses determined by batch_size and mass_range as well as positive class labels. The waveforms are clipped/padded to be 256 steps in length. Param: batch_size - Integer number of waveforms to produce Param: sample_rate (Hz) - Integer number of measurements per second Param: mass_range (solar masses) - List of form [lower_bound, upper_bound] for mass range Param: data - list containing generated waveforms as numpy arrays ''' data = [] mass_step = (mass_range[1] - mass_range[0]) / batch_size masses = np.arange(mass_range[0], mass_range[1], mass_step) for mass in masses: #Generating waveform wave, _ = get_td_waveform(approximant='IMRPhenomD', mass1=mass, mass2=mass, delta_t=1.0 / sample_rate, f_lower=25) #Cropping/padding to get waveforms of length 256 if len(wave) > 256: wave = wave[len(wave) - 256:] else: wave = np.concatenate([np.zeros(256 - len(wave)), wave]) #Normalizing waveform wave = wave / max(np.correlate(wave, wave, mode="full"))**0.5 #Saving waveform as numpy array data.append(np.asarray(wave)) labels = np.ones(len(data)) return np.asarray(data), labels
def get_waveform(approximant, phase_order, amplitude_order, template_params, start_frequency, sample_rate, length, filter_rate): if approximant in td_approximants(): hplus, hcross = get_td_waveform(template_params, approximant=approximant, phase_order=phase_order, delta_t=1.0 / sample_rate, f_lower=start_frequency, amplitude_order=amplitude_order) hvec = generate_detector_strain(template_params, hplus, hcross) if filter_rate != sample_rate: delta_t = 1.0 / filter_rate hvec = resample_to_delta_t(hvec, delta_t) elif approximant in fd_approximants(): delta_f = filter_rate / length if hasattr(template_params, "spin1z") and hasattr( template_params, "spin2z"): if template_params.spin1z <= -0.9 or template_params.spin1z >= 0.9: template_params.spin1z *= 0.99999999 if template_params.spin2z <= -0.9 or template_params.spin2z >= 0.9: template_params.spin2z *= 0.99999999 if True: print("\n spin1z = %f, spin2z = %f, chi = %f" % (template_params.spin1z, template_params.spin2z, lalsimulation.SimIMRPhenomBComputeChi( template_params.mass1 * lal.LAL_MSUN_SI, template_params.mass2 * lal.LAL_MSUN_SI, template_params.spin1z, template_params.spin2z)), file=sys.stderr) print("spin1x = %f, spin1y = %f" % (template_params.spin1x, template_params.spin1y), file=sys.stderr) print("spin2x = %f, spin2y = %f" % (template_params.spin2x, template_params.spin2y), file=sys.stderr) print("m1 = %f, m2 = %f" % (template_params.mass1, template_params.mass2), file=sys.stderr) hvec = get_fd_waveform(template_params, approximant=approximant, phase_order=phase_order, delta_f=delta_f, f_lower=start_frequency, amplitude_order=amplitude_order)[0] if True: print("filter_N = %d in get waveform" % filter_N, "\n type(hvec) in get_waveform:", type(hvec), file=sys.stderr) print(hvec, file=sys.stderr) print(hvec[0], file=sys.stderr) print(hvec[1], file=sys.stderr) print(isinstance(hvec, FrequencySeries), file=sys.stderr) htilde = make_padded_frequency_series(hvec, filter_N) return htilde
def genDesignMatrix(m1Range, m2Range, spzRange, del_tRange, f_lowRange, strict=False): try: if len(del_t) not in [1, 3] or len(f_low) not in [1, 3]: raise Exception('Syntax for arguments in genDesignMatrix()') except Exception: print 'del_t and f_low could either have a single value or a range, \ in range specify min, max and increment' EPSILON = myconstants.epsilon if len(del_tRange) == 1: del_tRange.append(del_tRange[0] + EPSILON) del_tRange.append(EPSILON) if len(f_lowRange) == 1: f_lowRange.append(f_lowRange[0] + EPSILON) f_lowRange.append(EPSILON) designMatrix = dict() designMatrix['amplitude'] = list() designMatrix['m1'] = list() designMatrix['m2'] = list() designMatrix['spz'] = list() designMatrix['del_t'] = list() designMatrix['f_low'] = list() # Size of the matrix is six because of, # m1, m2, spz, del_t, f_low and the amplitude (during coalescence) del_tRange = frange(del_tRange[0], del_tRange[1], del_tRange[2]) f_lowRange = frange(f_lowRange[0], f_lowRange[1], f_lowRange[2]) print '\nComputation START' loop = 1 for m1 in xrange(m1Range[0], m1Range[1], m1Range[2]): for m2 in xrange(m2Range[0], m2Range[1], m2Range[2]): if strict == True: if m1 < m2: continue for spz in frange(spzRange[0], spzRange[1], spzRange[2]): for del_t in del_tRange: for f_low in f_lowRange: for apx in ['SEOBNRv2']: print 'Entered loop: ' + str(loop) loop += 1 hp, hc = get_td_waveform(approximant=apx, \ mass1 = m1, \ mass2 = m2, \ spin1z = spz, \ delta_t = del_t,\ f_lower = f_low) designMatrix['amplitude'].append(max(hp)) designMatrix['m1'].append(m1) designMatrix['m2'].append(m2) designMatrix['spz'].append(spz) designMatrix['del_t'].append(del_t) designMatrix['f_low'].append(f_low) return designMatrix
def compute_hphc_td(self, t): hp, hc = get_td_waveform(**self.source_parameters) tm = hp.sample_times.numpy() + self.source_parameters['tc'] hp, hc = self.source2SSB(hp, hc) self._interp_hphc(tm, hp, hc, t, kind="spline") return (self.hp, self.hc)
def mixed_signals_BHBNSB(noise): global next_val,signal_gw #apx= with open('gdrive/My Drive/GW data/labels_mixed.csv', 'a', newline='') as file: for aab in ['TaylorT1', 'TaylorT2', 'EOBNRv2', 'SEOBNRv2']: print(aab) check=np.zeros(noise.shape[1]) k=0 for m1 in tqdm(range(5,16,5)): for m2 in range(5,16,5): for d in (range(50,501,100)): for fl in [60,120]: if (m1+m2+d+fl) not in check: check[k]=m1+m2+d+fl hp,hc = get_td_waveform(approximant=aab, mass1=m1,mass2=m2, delta_t=1.0/4096, f_lower=fl,f_final=50, distance=d) if len(hp)<=16384: t=np.linspace(0,.3,np.random.randint(16384)) y2=np.zeros(len(t)) r=.3 for j in range(3,8): for i in range(len(t)): aa=t[i]-0.0295-j*0.0295-(j*(j+1)/2)*r*0.0295 y2[i]+=1.5*10e-21*(-1)**j*(1.5*10e-21*.5/(3+j))*np.exp(-(aa**2)/(2*.006**2))*np.cos(2*np.pi*250*aa) wave=['helix2','whistle','wandering_line','violin_mode','Tomte','koi_fish','scratchy','scattered_light','repeating_blip','power_line','paired_dove','low_freq_burst','light_modulation'] for wave_name in wave: loc='gdrive/My Drive/GW data/Glitches/'+wave_name+'.wav' rate,data=s.read(loc) for c2 in [5,7]: b, a = signal.butter(7, .9, btype='lowpass', analog=False) low_passed = signal.filtfilt(b, a, data) z = 10e-28*signal.medfilt(low_passed,c2) sig=np.zeros(8820) jj=0 for ii in range(0,len(z),5): sig[jj]=z[ii] jj+=1 signal_gw[next_val:next_val+noise.shape[0],:]=np.copy(noise[:,::2]) pos=np.random.randint(0,signal_gw.shape[1]-int(np.ceil(len(hp)/2))) signal_gw[next_val:next_val+noise.shape[0] ,pos:pos+int(np.ceil(len(hp)/2))]+=hp[::2] pos=np.random.randint(0,signal_gw.shape[1]-int(np.ceil(len(sig)/2))) signal_gw[next_val:next_val+noise.shape[0], pos:pos+int(np.ceil(len(sig)/2))]+=sig[::2] pos=np.random.randint(0,signal_gw.shape[1]-int(np.floor(len(y2)/2))) signal_gw[next_val:next_val+noise.shape[0] ,pos:pos+int(np.ceil(len(y2)/2))]+=y2[::2] writer = csv.writer(file) for i in range(noise.shape[0]): col=np.zeros(27) col[m1//5-1],col[2+m2//4],col[5+d//50],col[10+fl//60],col[13],col[18],col[26]=1,1,1,1,1,1,1 writer.writerow(col) k=k+1 next_val+=(noise.shape[0])
def computeHPHC(argList): for apx in ['SEOBNRv2']: hp, hc = get_td_waveform(approximant=apx, \ mass1 = argList[0], \ mass2 = argList[1], \ spin1z = argList[2], \ delta_t = argList[3],\ f_lower = argList[4]) 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 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 reverse_chirp_td(**kwds): import numpy from pycbc.waveform import get_td_waveform if 'approximant' in kwds: kwds.pop("approximant") hp, hc = get_td_waveform(approximant="IMRPhenomD", **kwds) return (hp.to_frequencyseries().conj().to_timeseries(), hp.to_frequencyseries().conj().to_timeseries())
def computeHPHC(argList): for apx in ['SEOBNRv2']: hp, hc = get_td_waveform(approximant=apx, \ mass1 = argList[0], \ mass2 = argList[1], \ spin1z = argList[2], \ delta_t = argList[3],\ f_lower = argList[4]) plt.plot(hp.sample_times, hp, label=apx) 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 get_waveform(p, **kwds): """ Given the input parameters get me the waveform, whether it is TD or FD """ params = copy.copy(p.__dict__) params.update(kwds) if params['approximant'] in td_approximants(): return get_td_waveform(**params) else: return get_fd_waveform(**params)
def generate_GWChirp(): #returns + polarization of the gw chirp mass = 10 hp, hc = get_td_waveform(approximant='SEOBNRv4_opt', mass1=mass, mass2=mass, delta_t=1 / 4096, f_lower=20) return hp
def gen_pol(ms, apx, d_t, f_low): ''' Generates the plus and cross polarizations of a gravitational wave INPUT: ms: two-dimentional tuple. Masses of the merger apx: Waveform approximant d_t: sampling rate of the signal f_low: starting frequency of the signal ''' hp, hc = get_td_waveform(mass1=ms[0], mass2=ms[1], approximant=apx, delta_t=d_t, f_lower=f_low) return hp, hc
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 waveform(self, p, time_range, distance=1.0, coa_phase=0, t0=0, f_ref=100): """ Generate a single waveform from the catalogue. """ delta_t = (time_range[1] - time_range[0]) / time_range[2] mass1, mass2 = self.components_from_total(self.total_mass, p['mass ratio']) for par in self.parameters: if not par.replace("_", " ") in p: p[par.replace("_", " ")] = 0 hp, hx = get_td_waveform(approximant=self.approximant, mass1=mass1, mass2=mass2, spin1x=p['spin 1x'], spin1y=p['spin 1y'], spin1z=p['spin 1z'], spin2x=p['spin 2x'], spin2y=p['spin 2y'], spin2z=p['spin 2z'], distance=distance, delta_t=delta_t, coa_phase=coa_phase, f_ref=f_ref, f_lower=self.fmin) hp = Timeseries(hp) hx = Timeseries(hx) # Recenter the waveforms on the maximum strain hp.times -= hp.times[np.argmax(np.abs(hp.data - 1j * hx.data))] hx.times -= hx.times[np.argmax(np.abs(hp.data - 1j * hx.data))] # Recenter the waveforms now to some arbitrary time hp.times -= t0 hx.times -= t0 tix = (time_range[0] < hp.times) & (hp.times < time_range[1]) hp.times = hp.times[tix] hx.times = hx.times[tix] hp.data = hp.data[tix] hx.data = hx.data[tix] return hp, hx
def test_generation(self): with self.context: for waveform in td_approximants(): if waveform in failing_wfs: continue print(waveform) hc,hp = get_td_waveform(approximant=waveform,mass1=20,mass2=20,delta_t=1.0/4096,f_lower=40) self.assertTrue(len(hc)> 0) for waveform in fd_approximants(): if waveform in failing_wfs: continue print(waveform) htilde, g = get_fd_waveform(approximant=waveform,mass1=20,mass2=20,delta_f=1.0/256,f_lower=40) self.assertTrue(len(htilde)> 0)
def get_waveform(approximant, order, template_params, start_frequency, sample_rate, length): if approximant in fd_approximants(): delta_f = float(sample_rate) / length hvec = get_fd_waveform(template_params, approximant=approximant, phase_order=order, delta_f=delta_f, f_lower=start_frequency, amplitude_order=order) if approximant in td_approximants(): hplus,hcross = get_td_waveform(template_params, approximant=approximant, phase_order=order, delta_t=1.0 / sample_rate, f_lower=start_frequency, amplitude_order=order) hvec = hplus htilde = make_padded_frequency_series(hvec,filter_N) return htilde
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. """ f_l = inj.f_lower if f_lower is None else 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) return projector(detector_name, inj, hp, hc, distance_scale=distance_scale)
def get_waveform(wf_params, start_frequency, sample_rate, length, filter_rate, sky_max_template=False): delta_f = filter_rate / float(length) if wf_params.approximant in fd_approximants(): hp, hc = get_fd_waveform(wf_params, delta_f=delta_f, f_lower=start_frequency) elif wf_params.approximant in td_approximants(): hp, hc = get_td_waveform(wf_params, delta_t=1./sample_rate, f_lower=start_frequency) if not sky_max_template: hvec = generate_detector_strain(wf_params, hp, hc) return make_padded_frequency_series(hvec, length, delta_f=delta_f) else: return make_padded_frequency_series(hp, length, delta_f=delta_f), \ make_padded_frequency_series(hc, length, delta_f=delta_f)
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. """ 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) return projector(detector_name, inj, hp, hc, distance_scale=distance_scale)
def get_waveform(approximant, phase_order, amplitude_order, template_params, start_frequency, sample_rate, length): if approximant in td_approximants(): hplus,hcross = get_td_waveform(template_params, approximant=approximant, phase_order=phase_order, delta_t=1.0 / sample_rate, f_lower=start_frequency, amplitude_order=amplitude_order) hvec = generate_detector_strain(template_params, hplus, hcross) elif approximant in fd_approximants(): delta_f = sample_rate / length hvec = get_fd_waveform(template_params, approximant=approximant, phase_order=phase_order, delta_f=delta_f, f_lower=start_frequency, amplitude_order=amplitude_order) htilde = make_padded_frequency_series(hvec,filter_N) return htilde
def test_generation(self): with self.context: for waveform in good_waveforms: print(waveform) hc, hp = get_td_waveform(approximant=waveform, mass1=20, mass2=20, delta_t=1.0 / 4096, f_lower=40) self.assertTrue(len(hc) > 0) for waveform in good_waveforms: print(waveform) htilde, g = get_fd_waveform(approximant=waveform, mass1=20, mass2=20, delta_f=1.0 / 256, f_lower=40) self.assertTrue(len(htilde) > 0)
def FUNC(x): # Substitute the right parameter deriv_param = param_list['deriv_param'] param_list[deriv_param] = x # Compute the waveform if approximant in td_approximants(): test_hp, test_hc = get_td_waveform( approximant=approximant, mass1=param_list['mass1'], mass2=param_list['mass2'], spin1x=param_list['spin1x'], spin1y=param_list['spin1y'], spin1z=param_list['spin1z'], spin2x=param_list['spin2x'], spin2y=param_list['spin2y'], spin2z=param_list['spin2z'], distance=param_list['distance'], inclination=param_list['inclination'], coa_phase=param_list['coa_phase'], f_lower=f_lower, delta_t=delta_t) test_wav = generate_detector_strain(param_list, test_hp, test_hc) test_wav = extend_waveform_TimeSeries(test_wav, N) elif approximant in fd_approximants(): test_hp, test_hc = get_fd_waveform( approximant=approximant, mass1=param_list['mass1'], mass2=param_list['mass2'], spin1x=param_list['spin1x'], spin1y=param_list['spin1y'], spin1z=param_list['spin1z'], spin2x=param_list['spin2x'], spin2y=param_list['spin2y'], spin2z=param_list['spin2z'], distance=param_list['distance'], inclination=param_list['inclination'], coa_phase=param_list['coa_phase'], f_lower=f_lower, delta_f=delta_f) test_wav = generate_detector_strain(param_list, test_hp, test_hc) test_wav = extend_waveform_FrequencySeries(test_wav, n) # Return waveform return np.array(test_wav.data)
def gen_waveform(iota, phi, numrel_data): print "I am in gen_waveform()!" ## FIXME(Gonghan): It seems that this variable is never used. global wavelabel wavelabel = os.path.join(savepath, numrel_data.split('/')[-1].replace(".h5", "")) f = h5py.File(numrel_data, 'r') global hp, hc hp, hc = get_td_waveform(approximant='NR_hdf5', numrel_data=numrel_data, mass1=f.attrs['mass1'] * mass, mass2=f.attrs['mass2'] * mass, spin1z=f.attrs['spin1z'], spin2z=f.attrs['spin2z'], delta_t=1.0 / sample_frequency, f_lower=30., inclination=iota, coa_phase=phi, distance=1000) print "in gen_waveform, have got hp, hc. iota: {}, phi: {}".format( iota, phi) print "hp:", hp print "hc:", hc f.close() # Taper waveform for smooth FFTs hp = taper_timeseries(hp, tapermethod="TAPER_START") hc = taper_timeseries(hc, tapermethod="TAPER_START") global amp, foft amp = wfutils.amplitude_from_polarizations(hp, hc) foft = wfutils.frequency_from_polarizations(hp, hc) # Shift time origin to merger global sample_times ## FIXME(Gonghan): Not sure how we want to define zero time. sample_times = amp.sample_times - amp.sample_times[np.argmax(amp)]
from pycbc.waveform import get_td_waveform from pycbc.filter import match from pycbc.psd import aLIGOZeroDetHighPower f_low = 30 sample_rate = 4096 # Generate the two waveforms to compare hp, hc = get_td_waveform(approximant="EOBNRv2", mass1=10, mass2=10, f_lower=f_low, delta_t=1.0/sample_rate) sp, sc = get_td_waveform(approximant="TaylorT4", mass1=10, mass2=10, f_lower=f_low, delta_t=1.0/sample_rate) # Resize the waveforms to the same length tlen = max(len(sp), len(hp)) sp.resize(tlen) hp.resize(tlen) # Generate the aLIGO ZDHP PSD delta_f = 1.0 / sp.duration flen = tlen/2 + 1 psd = aLIGOZeroDetHighPower(flen, delta_f, f_low) # Note: This takes a while the first time as an FFT plan is generated
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, spin1y=0.0, spin2y=0.0, spin1z=simulations.simulations[0]["spin1z"], spin2z=simulations.simulations[0]["spin2z"], inclination=inc, f_lower=f_low_approx * min(masses) / mass, delta_t=delta_t, ) hplus_approx = wfutils.taper_timeseries(hplus_approx, "TAPER_STARTEND") hcross_approx = wfutils.taper_timeseries(hcross_approx, "TAPER_STARTEND") approx_freqs = wfutils.frequency_from_polarizations(hplus_approx, hcross_approx) # elif approx == 'IMRPhenomPv2' or approx == 'IMRPhenomP': elif approx in fd_approximants():
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 # earth using the project wave function. hp.start_time = hc.start_time = time ht = d.project_wave(hp, hc, ra, dec, pol)
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=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)
spin_magnitudes.append((simulation['a1'], simulation['a2'])) spin_angles.append((simulation['th1L'], simulation['th2L'])) mass1, mass2 = component_masses(total_mass, mass_ratios[s]) spin1z = cartesian_spins(simulation['a1'], simulation['th1L']) spin2z = cartesian_spins(simulation['a2'], simulation['th2L']) effective_spins[s] = spawaveform.computechi(mass1, mass2, spin1z, spin2z) print "Generating EOBNR" hplus_EOBNR, _ = get_td_waveform(approximant="SEOBNRv2", distance=distance, mass1=mass1, mass2=mass2, spin1z=spin1z, spin2z=spin2z, f_lower=f_low, delta_t=SI_deltaT) # divide out the spherical harmonic (2,2) amplitude (this is just for nice # plots / sanity - it does not affect match) sY22 = lal.SpinWeightedSphericalHarmonic(0,0,-2,2,2) hplus_EOBNR.data /= np.real(sY22) # (1-sided) Planck window for smooth FFT hplus_EOBNR.data = bwave.window_wave(hplus_EOBNR.data) # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # # Match Calculation
# Plot a time domain and fourier domain waveform together in the time domain. # Note that without special cleanup the Fourier domain waveform will exhibit # the Gibb's phenomenon. (http://en.wikipedia.org/wiki/Gibbs_phenomenon) import pylab from pycbc import types, fft, waveform # Get a time domain waveform hp, hc = waveform.get_td_waveform(approximant="EOBNRv2", mass1=6, mass2=6, delta_t=1.0/4096, f_lower=40) # Get a frequency domain waveform sptilde, sctilde = waveform. get_fd_waveform(approximant="TaylorF2", mass1=6, mass2=6, delta_f=1.0/4, f_lower=40) # FFT it to the time-domain tlen = int(1.0 / hp.delta_t / sptilde.delta_f) sptilde.resize(tlen/2 + 1) sp = types.TimeSeries(types.zeros(tlen), delta_t=hp.delta_t) fft.ifft(sptilde, sp) pylab.plot(sp.sample_times, sp, label="TaylorF2 (IFFT)") pylab.plot(hp.sample_times, hp, label="EOBNRv2") pylab.ylabel('Strain') pylab.xlabel('Time (s)') pylab.legend() pylab.show()
# --- Generate the polarisations hplus_NR, hcross_NR = nrbu.get_wf_pols( simulations.simulations[sim_number]['wavefile'], mass, inclination=inc, delta_t=delta_t, f_lower=30.0001, distance=distance) # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # 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
import pylab from pycbc.waveform import get_td_waveform for apx in ['SEOBNRv2', 'IMRPhenomC']: hp, hc = get_td_waveform(approximant=apx, mass1=10, mass2=10, spin1z=0.9, delta_t=1.0/4096, f_lower=40) pylab.plot(hp.sample_times, hp, label=apx) pylab.ylabel('Strain') pylab.xlabel('Time (s)') pylab.legend() pylab.show()
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[:]
import pylab from pycbc import waveform for apx in ["EOBNRv2", "TaylorT4", "IMRPhenomB"]: hp, hc = waveform.get_td_waveform(approximant=apx, mass1=10, mass2=10, delta_t=1.0 / 4096, f_lower=40) hp, hc = hp.trim_zeros(), hc.trim_zeros() amp = waveform.utils.amplitude_from_polarizations(hp, hc) phase = waveform.utils.phase_from_polarizations(hp, hc) pylab.plot(phase, amp, label=apx) pylab.ylabel("GW Strain Amplitude") pylab.xlabel("GW Phase (radians)") pylab.legend(loc="upper left") pylab.show()
import pylab from pycbc.waveform import get_td_waveform from pycbc.detector import Detector apx = 'SEOBNRv4' # NOTE: Inclination runs from 0 to pi, with poles at 0 and pi # coa_phase runs from 0 to 2 pi. hp, hc = get_td_waveform(approximant=apx, mass1=10, mass2=10, spin1z=0.9, spin2z=0.4, inclination=1.23, coa_phase=2.45, delta_t=1.0/4096, f_lower=40) det_h1 = Detector('H1') det_l1 = Detector('L1') det_v1 = Detector('V1') # Choose a GPS end time, sky location, and polarization phase for the merger # NOTE: Right ascension and polarization phase runs from 0 to 2pi # Declination runs from pi/2. to -pi/2 with the poles at pi/2. and -pi/2. end_time = 1192529720 declination = 0.65 right_ascension = 4.67 polarization = 2.34 hp.start_time += end_time hc.start_time += end_time
# Parse trigger files into SNR, time, and frequency for Omicron triggers for file in file_list: omicron_xml = utils.load_filename(file, contenthandler=DefaultContentHandler) snglburst_table = table.get_table(omicron_xml, lsctables.SnglBurstTable.tableName) for row in snglburst_table: if (row.snr > args.omicron_snr_thresh and omicron_start_time < row.peak_time < omicron_end_time): omicron_times.append(row.peak_time + row.peak_time_ns * 10**(-9)) omicron_snr.append(row.snr) omicron_freq.append(row.peak_frequency) # Generate inspiral waveform and calculate f(t) to plot on top of Omicron triggers hp, hc = get_td_waveform(approximant='SEOBNRv2', mass1=m1, mass2=m2, spin1x=0, spin1y=0, spin1z=s1z, spin2x=0, spin2y=0, spin2z=s2z, delta_t=(1./32768.), f_lower=30) f = frequency_from_polarizations(hp, hc) amp = amplitude_from_polarizations(hp, hc) stop_idx = amp.abs_max_loc()[1] f = f[:stop_idx] freq = np.array(f.data) times = np.array(f.sample_times) + cbc_end_time logging.info('Plotting') plt.figure(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
import pylab from pycbc import waveform for phase_order in [2, 3, 4, 5, 6, 7]: hp, hc = waveform.get_td_waveform(approximant='SpinTaylorT4', mass1=10, mass2=10, phase_order=phase_order, delta_t=1.0/4096, f_lower=100) hp, hc = hp.trim_zeros(), hc.trim_zeros() amp = waveform.utils.amplitude_from_polarizations(hp, hc) f = waveform.utils.frequency_from_polarizations(hp, hc) pylab.plot(f.sample_times, f, label="PN Order = %s" % phase_order) pylab.ylabel('Frequency (Hz)') pylab.xlabel('Time (s)') pylab.legend(loc='upper left') pylab.show()
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