Beispiel #1
0
def BLWNB(f,df,dt,fs):
    #BLWNB - Generate a random signal of given duration with constant power
    #in a given band (and zero power out of band).

    #   x = blwnb(f,df,dt,fs)
    #
    #   f   Scalar. Minimum signal frequency [Hz].
    #   df  Scalar. Full signal bandwidth [Hz].
    #   dt  Scalar. Signal duration [s].
    #   fs  Scalar. Signal sample rate [Hz].

    # Power is restricted to the band (f,f+df). 
    # Note that fs must be greater than 2*(f+df).

    # original version: L. S. Finn, 2004.08.03

    # $Id: BLWNB.m 4992 2015-07-25 18:59:12Z [email protected] $

    #% ---- Check that fs > 2*(f+df), otherwise sampling rate is not high enough to
    #       cover requested frequency range of the signal.
    if (fs <= abs(2*(f+df))):
        raise ValueError('Sampling rate fs is too small, fs = '+str(fs)+' must be greater than 2*(f+df) = '+str(np.abs(2*(f+df))))


    if f < 0 or df <= 0 or fs <= 0 or dt <= 0 :
        raise ValueError('All arguments must be greater than zero')

    #% ---- Generate white noise with duration dt at sample rate df. This will be
    #%      white over the band [-df/2,df/2].

    nSamp = ceil(dt*df)
    x_old = TimeSeries(np.random.randn(nSamp),sample_rate=1/dt)
    


    #% ---- Resample to desired sample rate fs.
    x=x_old.resample(fs/df)
    #frac = Fraction(Decimal(fs/df))
    #p, q = frac.numerator , frac.denominator


    #% ---- Note that the rat() function returns p,q values that give the desired
    #%      ratio to a default accuracy of 1e-6. This is a big enough error that
    #%      x may be a few samples too short or too long. If too long, then truncate
    #%      to duration dt. If too short, zero-pad to duration dt.
    #print((np.zeros(nSamp-len(x)).shape))
    nSamp = round(dt*fs)
    if len(x) > nSamp:
        x = x[0:nSamp]
    elif len(x) < nSamp:
        x=np.hstack((np.array(x),np.zeros(nSamp-len(x))))

    #% ---- Heterodyne up by f+df/2 (moves zero frequency to center of desired band).
    fup = f+df/2.
    x = x*np.exp(-2*np.pi*1j*fup/fs*np.arange(1,len(x)+1))

    #% ---- Take real part and adjust amplitude.
    x = np.array(np.real(x)/np.sqrt(2))
    #% ---- Done.
    return(x)
Beispiel #2
0
def prep_ccsn(h, sim_times, Tc, fw):
    """Function to prepare a single polarization of a simulated ccsn waveform - resample, high pass filter and window
	"""
    dt = sim_times[1] - sim_times[0]
    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))
    return h
Beispiel #3
0
    def compute(self, raw: TimeSeries) -> TimeSeriesDict:
        debug = f'compute_blrms ({self.channel}) : '

        # resample to specified frequency.
        raw = raw.resample(**better_aa_opts(raw, self.fs))

        # compute spectogram. Set up kwargs for creation of output TimeSeries.
        F, T, Sh = spectrogram(raw.value,
                               nperseg=self.fs * self.tn,
                               noverlap=int(self.fs * self.to),
                               fs=self.fs)
        ts_kwargs = dict(t0=raw.t0, dt=T[1] - T[0], unit=raw.unit)
        logger.debug(debug + 'Computed scipy.spectrogram.')

        # identify lines by comparing the PSD to a calculated background.
        Sh_m = median(Sh, axis=1)  # get median PSD for each time.
        Nf = int(self.df /
                 F[1])  # convert the median window in number of bins.
        Sb_m = zeros_like(Sh_m)  # start with empty background vector.
        # compute a windowed median of the PSD.
        for i, f in enumerate(F):
            # select the bins in the current window.
            idx = arange(max(i - Nf, 0), min(i + Nf, F.shape[0]))
            # compute estimate of background (without lines) by computing the median in the current window.
            Sb_m[i] = median(Sh_m[idx])
        else:
            logger.debug(debug + 'Estimated PSD of background.')
        # find all lines, i.e. all bins where the PSD is larger than thr times the background.
        line_idx = where(logical_and(F > 10, Sh_m / Sb_m > self.thr))[0]
        logger.debug(debug + 'Located the line frequencies.')

        # Compute BLRMS for all bands
        out = TimeSeriesDict()
        for band_start, band_stop in self.bands:
            channel_prefix = f'{self.channel}_BLRMS_{band_start}_{band_stop}'
            # select frequency bins.
            idx = arange(int(band_start / F[1]), int(band_stop / F[1]))
            # full BLRMS, using all bins.
            out[channel_prefix] = TimeSeries(sum(Sh[idx, :], axis=0),
                                             **ts_kwargs)
            # remove the index of all lines.
            idx = setdiff1d(idx, line_idx)
            # compute BLRMS excluding lines.
            out[f'{channel_prefix}_nolines'] = TimeSeries(
                sum(Sh[idx, :], axis=0), **ts_kwargs)

            # Time-domain median smoothing and glitch removal
            for prefix in channel_prefix, f'{channel_prefix}_nolines':
                blrms = out[prefix].value
                # convert the time-domain median window size from seconds to BLRMS samples
                NT = int(self.dt / T[1])
                # empty vectors for running median and running 'median-stdev'
                blrms_m = zeros_like(blrms)
                blrms_rms = zeros_like(blrms)
                # loop over all time samples
                for i, x in enumerate(blrms):
                    # select samples in current window
                    idx = arange(max(i - NT, 0), min(i + NT, T.shape[0]))
                    # median of the BLRMS in the current window
                    blrms_m[i] = median(blrms[idx])
                    # median-based equivalent of the variance
                    blrms_rms[i] = median((blrms[idx] - blrms_m[i])**2)
                # identify all glitch times as samples when the BLRMS deviated from median more than 3 times the median-stdev
                glitch_idx = where((blrms - blrms_m) > 3 * sqrt(blrms_rms))[0]
                # remove the glitchy times
                blrms_noglitch = blrms.copy()  # first set glitchy times to NaN
                blrms_noglitch[glitch_idx] = NaN
                idx = isnan(
                    blrms_noglitch)  # then find the samples that are glitchy
                # linear interpolation using values around glitches
                blrms_noglitch[idx] = interp(T[idx], T[~idx], blrms[~idx])
                # save results to dictionary
                out[f'{prefix}_smooth'] = TimeSeries(blrms_m, **ts_kwargs)
                out[f'{prefix}_noglitch'] = TimeSeries(blrms_noglitch,
                                                       **ts_kwargs)

        # F_lines = F[line_idx]
        # lines = {'F_lines': F_lines, 'F': F, 'Smedian': Sh_m, 'Sbg': Sb_m, 'line_idx': line_idx}

        # fix channel names.
        for i in out:
            out[i].name = i

        return out
Beispiel #4
0
def load_inject_condition_ccsn(t_i, t_f, t_inj, ra, dec, ccsn_paper, ccsn_file, D_kpc=10, 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.
	"""
	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, 0, 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)

	
	cond_data = condition_data(injected_data, To, fw, window, qtrans, qsplit, dT)

	x = []
	times = []

	for dat in cond_data:
		x.append(dat.values)
		times.append(dat.t0)

	x = np.asarray(x)
	times = np.asarray(times)

	idx = find_closest_index(t_inj, times)

	x = x[idx]
	times = times[idx]
	return x, times
Beispiel #5
0
# Strain
# -----------
if False:
    chname = 'CALC_STRAIN'
    segments = findfiles(start,
                         end,
                         chname,
                         prefix='/Users/miyo/Dropbox/KagraData/gif')
    source = [path for files in segments for path in files]
    strain = TimeSeries.read(source=source,
                             name=chname,
                             format='gif',
                             pad=numpy.nan,
                             nproc=1)
    strain = TimeSeries(strain.value, times=strain.times.value, name=chname)
    strain = strain.resample(8.0)
    #strain.write('Dec10_3hours_strain.gwf',format='gwf.lalframe')

# -----------
# Pressure
# -----------
if True:
    chname = 'X500_BARO'
    segments = findfiles(start,
                         end,
                         chname,
                         prefix='/Users/miyo/Dropbox/KagraData/gif')
    source = [path for files in segments for path in files]
    x500_baro = TimeSeries.read(source=source,
                                name=chname,
                                format='gif',