def time_delay_from_earth_center(self, right_ascension, declination, t_gps): """Return the time delay from the earth center """ return lal.TimeDelayFromEarthCenter(self.location, float(right_ascension), float(declination), float(t_gps))
def delay_and_amplitude_correct(event, ra, dec): # retrieve station metadata detector = lal.cached_detector_by_prefix[event.ifo] # delay-correct the event to the geocentre delay = lal.TimeDelayFromEarthCenter(detector.location, ra, dec, event.peak) event.peak -= delay event.period = event.period.shift(-delay) try: event.ms_peak -= delay except AttributeError: pass try: event.ms_period = event.ms_period.shift(-delay) except AttributeError: pass # amplitude-correct the event using the polarization-averaged # antenna response fp, fc = lal.ComputeDetAMResponse( detector.response, ra, dec, 0, lal.GreenwichMeanSiderealTime(event.peak)) mean_response = math.sqrt(fp**2 + fc**2) event.amplitude /= mean_response event.ms_hrss /= mean_response # done return event
def make_bbh(hp, hc, fs, ra, dec, psi, det): """ turns hplus and hcross into a detector output applies antenna response and and applies correct time delays to each detector """ # make basic time vector tvec = np.arange(len(hp)) / float(fs) # compute antenna response and apply Fp, Fc, _, _ = antenna.response(0.0, ra, dec, 0, psi, 'radians', det) ht = hp * Fp + hc * Fc # overwrite the timeseries vector to reuse it # compute time delays relative to Earth centre frDetector = lalsimulation.DetectorPrefixToLALDetector(det) tdelay = lal.TimeDelayFromEarthCenter(frDetector.location, ra, dec, 0.0) print '{}: computed {} Earth centre time delay = {}'.format( time.asctime(), det, tdelay) # interpolate to get time shifted signal ht_tck = interpolate.splrep(tvec, ht, s=0) hp_tck = interpolate.splrep(tvec, hp, s=0) hc_tck = interpolate.splrep(tvec, hc, s=0) tnew = tvec + tdelay new_ht = interpolate.splev(tnew, ht_tck, der=0, ext=1) new_hp = interpolate.splev(tnew, hp_tck, der=0, ext=1) new_hc = interpolate.splev(tnew, hc_tck, der=0, ext=1) return new_ht, new_hp, new_hc
def make_bbh(hp, hc, fs, ra, dec, psi, det): """ Turns hplus and hcross into a detector output applies antenna response and and applies correct time delays to each detector Parameters ---------- hp: h-plus version of GW waveform hc: h-cross version of GW waveform fs: sampling frequency ra: right ascension dec: declination psi: polarization angle det: detector Returns ------- ht: combined h-plus and h-cross version of waveform hp: h-plus version of GW waveform hc: h-cross version of GW waveform """ # make basic time vector tvec = np.arange(len(hp)) / float(fs) # compute antenna response and apply Fp, Fc, _, _ = antenna.response(float(event_time), ra, dec, 0, psi, 'radians', det) ht = hp * Fp + hc * Fc # overwrite the timeseries vector to reuse it # compute time delays relative to Earth centre frDetector = lalsimulation.DetectorPrefixToLALDetector(det) tdelay = lal.TimeDelayFromEarthCenter(frDetector.location, ra, dec, float(event_time)) if verb: print '{}: computed {} Earth centre time delay = {}'.format( time.asctime(), det, tdelay) # interpolate to get time shifted signal ht_tck = interpolate.splrep(tvec, ht, s=0) hp_tck = interpolate.splrep(tvec, hp, s=0) hc_tck = interpolate.splrep(tvec, hc, s=0) if gw_tmp: tnew = tvec - tdelay else: tnew = tvec - tdelay # + (np.random.uniform(low=-0.037370920181274414,high=0.0055866241455078125)) new_ht = interpolate.splev(tnew, ht_tck, der=0, ext=1) new_hp = interpolate.splev(tnew, hp_tck, der=0, ext=1) new_hc = interpolate.splev(tnew, hc_tck, der=0, ext=1) return ht, hp, hc
def compute_arrival_time_at_detector(det, RA, DEC, tref): """ Function to compute the time of arrival at a detector from the time of arrival at the geocenter. 'det' is a detector prefix string (e.g. 'H1') 'RA' and 'DEC' are right ascension and declination (in radians) 'tref' is the reference time at the geocenter. It can be either a float (in which case the return is a float) or a GPSTime object (in which case it returns a GPSTime) """ detector = lalsim.DetectorPrefixToLALDetector(det) # if tref is a float or a GPSTime object, # it shoud be automagically converted in the appropriate way return tref + lal.TimeDelayFromEarthCenter(detector.location, RA, DEC, tref)
def time_delay_from_earth_center(self, skypoints, time=None): """ Returns the time delay from the earth center skypoints: Skypoint object or list of Skypoint objects (in the same coordinate system) This function uses LALTimeDelayFromEarthCenter() that takes equatorial coordinates (RA and dec) and a reference GPS time to define the sky location. If the skypoints are given in the equatorial coordinate system, the time delays are computed at the provided time if not None, otherwise it is computed at the reference time of the coordinate system of the skypoints. If the skypoints are given in the geographic coordinate system, they are mapped to fiducial equatorial coordinate system with GMST = 0 hr (REFDATE_GMST_ZERO). """ if not isinstance(skypoints, list): skypoints = [skypoints] delays = [] for p in skypoints: assert p.coordsystem.is_valid(), "Unsupported coordinate system" # TimeDelayFromEarthCenter() requires equatorial coordinates. # We transform the points with Earth-fixed coordsystem ('geographic') # to the fiducial equatorial coordinates system with GMST = 0 hr. if p.coordsystem.name == 'geographic': p = p.transformed_to(FIDUCIAL_EQUATORIAL_COORDSYS_GMST_ZERO) assert time is None, \ 'time cannot be forced for skypoints in the geographic coordinate system' time = p.coordsystem.ref_time else: time = time if time is not None else p.coordsystem.ref_time # TimeDelayFromEarthCenter() takes equatorial coordinates (RA and dec) # and a GPS reference time to define a sky location delays.append(lal.TimeDelayFromEarthCenter(self.location, \ *p.coords(fmt='lonlat',unit='radians'), time)) return numpy.squeeze(numpy.array(delays))
fig_list = {} indx = 0 t_ref = wfP.P.tref # This SHOULD NOT BE USED, if you want to time-align your signal if opts.t_ref: t_ref = float(opts.t_ref) else: print(" Warning: no reference time, it will be very difficult to time-align your signals ") for ifo in ['H1', 'L1', 'V1']: indx += 1 fig_list[ifo] = indx plt.figure(indx) wfP.P.detector = ifo data_dict_T[ifo] = wfP.real_hoft(no_memory=opts.no_memory,hybrid_use=opts.hybrid_use,hybrid_method=opts.hybrid_method) tvals = data_dict_T[ifo].deltaT*np.arange(data_dict_T[ifo].data.length) + float(data_dict_T[ifo].epoch) det = lalsim.DetectorPrefixToLALDetector(ifo) print(ifo, " T_peak =", P.tref + lal.TimeDelayFromEarthCenter(det.location, P.phi, P.theta, P.tref) - t_ref) if opts.verbose: plt.plot(tvals - wfP.P.tref, data_dict_T[ifo].data.data) np.savetxt(ifo+"_nr_"+group+"_"+str(param)+"_event_"+str(opts.event)+".dat", np.array([tvals -t_ref, data_dict_T[ifo].data.data]).T) if opts.verbose and not opts.save_plots: plt.show() if opts.save_plots: for ifo in fig_list: plt.figure(fig_list[ifo]) plt.savefig("response-"+str(ifo)+group+"_"+str(param)+fig_extension)
signal_models = [timing.SignalModel(_) for _ in W] # Get SNR=1 horizon distances for each detector. horizons = np.asarray([ signal_model.get_horizon_distance() for signal_model in signal_models ]) # Get antenna factors for each detector. Fplus, Fcross = np.asarray([ lal.ComputeDetAMResponse(response, ra, dec, psi, gmst) for response in responses ]).T # Compute TOAs at each detector. toas = np.asarray([ lal.TimeDelayFromEarthCenter(location, ra, dec, epoch) for location in locations ]) # Compute SNR in each detector. snrs = (0.5 * (1 + u2) * Fplus + 1j * u * Fcross) * horizons / DL abs_snrs = np.abs(snrs) arg_snrs = np.angle(snrs) if opts.measurement_error == 'zero-noise': pass elif opts.measurement_error == 'from-truth': # If user asked, apply noise to amplitudes /before/ adding noise to # TOAs and phases.
signal_models = [ timing.SignalModel(m1, m2, psds[ifo], f_low, approximant, amplitude_order, phase_order) for ifo in opts.detector] # Get SNR=1 horizon distances for each detector. horizons = np.asarray([signal_model.get_horizon_distance() for signal_model in signal_models]) # Get antenna factors for each detector. Fplus, Fcross = np.asarray([ lal.ComputeDetAMResponse(response, ra, dec, psi, gmst) for response in responses]).T # Compute TOAs at each detector. toas = np.asarray([lal.TimeDelayFromEarthCenter(location, ra, dec, epoch) for location in locations]) # Compute SNR in each detector. snrs = (0.5 * (1 + u2) * Fplus + 1j * u * Fcross) * horizons / DL abs_snrs = np.abs(snrs) arg_snrs = np.angle(snrs) if opts.measurement_error == 'zero-noise': pass elif opts.measurement_error == 'from-truth': # If user asked, apply noise to amplitudes /before/ adding noise to TOAs and phases. # Add noise to SNR estimates. abs_snrs += np.random.randn(len(abs_snrs))
def simulate_snr(ra, dec, psi, inc, distance, epoch, gmst, H, S, response, location, measurement_error='zero-noise'): from scipy.interpolate import interp1d from ..bayestar import filter from ..bayestar.interpolation import interpolate_max duration = 0.1 # Calculate whitened template autocorrelation sequence. HS = filter.signal_psd_series(H, S) n = len(HS.data.data) acor, sample_rate = filter.autocorrelation(HS, duration) # Calculate time, amplitude, and phase. u = np.cos(inc) u2 = np.square(u) signal_model = filter.SignalModel(HS) horizon = signal_model.get_horizon_distance() Fplus, Fcross = lal.ComputeDetAMResponse(response, ra, dec, psi, gmst) toa = lal.TimeDelayFromEarthCenter(location, ra, dec, epoch) z = (0.5 * (1 + u2) * Fplus + 1j * u * Fcross) * horizon / distance # Calculate complex autocorrelation sequence. snr_series = z * np.concatenate((acor[:0:-1].conj(), acor)) # If requested, add noise. if measurement_error == 'gaussian-noise': sigmasq = 4 * np.sum(HS.deltaF * np.abs(HS.data.data)) amp = 4 * n * HS.deltaF**0.5 * np.sqrt(HS.data.data / sigmasq) N = lal.CreateCOMPLEX16FrequencySeries('', HS.epoch, HS.f0, HS.deltaF, HS.sampleUnits, n) N.data.data = amp * (np.random.randn(n) + 1j * np.random.randn(n)) noise_term, sample_rate_2 = filter.autocorrelation(N, 2 * duration - 1 / sample_rate, normalize=False) assert sample_rate == sample_rate_2 snr_series += noise_term # Shift SNR series to the nearest sample. int_samples, frac_samples = divmod( (1e-9 * epoch.gpsNanoSeconds + toa) * sample_rate, 1) if frac_samples > 0.5: int_samples += 1 frac_samples -= 1 epoch = lal.LIGOTimeGPS(epoch.gpsSeconds, 0) n = len(acor) - 1 mprime = np.arange(-n, n + 1) m = mprime + frac_samples re, im = (interp1d(m, x, kind='cubic', bounds_error=False, fill_value=0)(mprime) for x in (snr_series.real, snr_series.imag)) snr_series = re + 1j * im # Find the trigger values. i_nearest = np.argmax(np.abs( snr_series[n - n // 2:n + n // 2 + 1])) + n - n // 2 i_interp, z_interp = interpolate_max(i_nearest, snr_series, n // 2, method='lanczos') toa = epoch + (int_samples + i_interp - n) / sample_rate snr = np.abs(z_interp) phase = np.angle(z_interp) # Shift and truncate the SNR time series. epoch += (int_samples + i_nearest - n - n // 2) / sample_rate snr_series = snr_series[(i_nearest - n // 2):(i_nearest + n // 2 + 1)] tseries = lal.CreateCOMPLEX8TimeSeries('snr', epoch, 0, 1 / sample_rate, lal.DimensionlessUnit, len(snr_series)) tseries.data.data = snr_series return horizon, snr, phase, toa, tseries
def time_delay_from_earth_center(self, RA, dec, time_gps): """ Returns the time delay from the earth center """ return lal.TimeDelayFromEarthCenter(self.location, float(RA), float(dec), float(time_gps))