def get_swstat_bits(frame_filenames, swstat_channel_name, start_time, end_time): ''' This function just checks the first time in the SWSTAT channel to see if the filter was on, it doesn't check times beyond that. This is just for a first test on a small chunck of data. To read the SWSTAT bits, reference: https://dcc.ligo.org/DocDB/0107/T1300711/001/LIGO-T1300711-v1.pdf Bit 0-9 = Filter on/off switches for the 10 filters in an SFM. Bit 10 = Filter module input switch on/off Bit 11 = Filter module offset switch on/off Bit 12 = Filter module output switch on/off Bit 13 = Filter module limit switch on/off Bit 14 = Filter module history reset momentary switch ''' # read frames swstat = frame.read_frame(frame_filenames, swstat_channel_name, start_time=start_time, end_time=end_time) # convert number in channel to binary bits = bin(int(swstat[0])) # check if filterbank input or output was off filterbank_off = False if len(bits) < 14 or int(bits[-13]) == 0 or int(bits[-11]) == 0: filterbank_off = True return bits[-10:], filterbank_off
def strain(self, ifo, duration=32, sample_rate=4096): """ Return strain around the event Currently this will return the strain around the event in the smallest format available. Selection of other data is not yet available. Parameters ---------- ifo: str The name of the observatory you want strain for. Ex. H1, L1, V1 Returns ------- strain: pycbc.types.TimeSeries Strain around the event. """ from astropy.utils.data import download_file from pycbc.frame import read_frame if sample_rate == 4096: sampling = "4KHz" elif sample_rate == 16384: sampling = "16KHz" channel = "{}:GWOSC-{}_R1_STRAIN".format(ifo, sampling.upper()) for fdict in self.data['strain']: if (fdict['detector'] == ifo and fdict['duration'] == duration and fdict['sampling_rate'] == sample_rate and fdict['format'] == 'gwf'): url = fdict['url'] break filename = download_file(url, cache=True) return read_frame(str(filename), str(channel))
def get_noise(detector): from pycbc import frame import random as randi import os h1_list = ['H-H1_LOSC_16_V1-1126084608-4096.gwf', 'H-H1_LOSC_16_V1-1126109184-4096.gwf', 'H-H1_LOSC_16_V1-1126264832-4096.gwf', 'H-H1_LOSC_16_V1-1126293504-4096.gwf', 'H-H1_LOSC_16_V1-1127194624-4096.gwf', 'H-H1_LOSC_16_V1-1128042496-4096.gwf', 'H-H1_LOSC_16_V1-1128345600-4096.gwf', 'H-H1_LOSC_16_V1-1128407040-4096.gwf', 'H-H1_LOSC_16_V1-1128624128-4096.gwf', 'H-H1_LOSC_16_V1-1128665088-4096.gwf', 'H-H1_LOSC_16_V1-1129127936-4096.gwf', 'H-H1_LOSC_16_V1-1129664512-4096.gwf'] h1_begin = [1126084608, 1126109184, 1126264832, 1126293504, 1127194624, 1128042496, 1128345600, 1128407040, 1128624128, 1128665088, 1129127936, 1129664512] if detector == 'O1-H': file = 'H-H1_LOSC_16_V1-1126084608-4096.gwf' strain = frame.read_frame(file, 'H1:GWOSC-16KHZ_R1_STRAIN',1126084608,1126084608+32) return strain
def strain(self, ifo): """ Return strain around the event Currently this will return the strain around the event in the smallest format available. Selection of other data is not yet available. Parameters ---------- ifo: str The name of the observatory you want strain for. Ex. H1, L1, V1 Returns ------- strain: pycbc.types.TimeSeries Strain around the event. """ import tempfile, requests, shutil from pycbc.frame import read_frame channel = '%s:LOSC-STRAIN' % ifo url = self.data['frames'][ifo] f = tempfile.NamedTemporaryFile(suffix='.gwf') r = requests.get(url, stream=True) if r.status_code != 200: raise ValueError("Could not download file, %s", r.status_code) shutil.copyfileobj(r.raw, f) f.flush() return read_frame(f.name, channel)
def loadts(self, inj): """Loads an injection time series. After the first time a time series is loaded it will be added to an internal buffer for faster in case another injection uses the same series. """ if self._buffer is None: # create the buffer self._buffer = LimitedSizeDict(size_limit=self._buffersize) try: return self._buffer[inj.filename] except KeyError: pass # not in buffer, so load if inj.filename.endswith('.gwf'): try: channel = inj.channel except AttributeError as _err: # Py3.XX: uncomment the "from _err" when we drop 2.7 raise ValueError("Must provide a channel for " "frame files") #from _err ts = frame.read_frame(inj.filename, channel) else: ts = load_timeseries(inj.filename) # cache self._buffer[inj.filename] = ts return ts
def strain(self, ifo): """ Return strain around the event Currently this will return the strain around the event in the smallest format available. Selection of other data is not yet available. Parameters ---------- ifo: str The name of the observatory you want strain for. Ex. H1, L1, V1 Returns ------- strain: pycbc.types.TimeSeries Strain around the event. """ import tempfile, requests, shutil from pycbc.frame import read_frame channel = '%s:LOSC-STRAIN' % ifo url = self.data['frames'][ifo] f = tempfile.NamedTemporaryFile(suffix='.gwf') r = requests.get(url, stream=True) if r.status_code != 200: raise ValueError("Could not download file, %s", r.status_code) shutil.copyfileobj(r.raw, f) f.flush() return read_frame(f.name, channel)
def strain(self, ifo, duration=32, sample_rate=4096): """ Return strain around the event Currently this will return the strain around the event in the smallest format available. Selection of other data is not yet available. Parameters ---------- ifo: str The name of the observatory you want strain for. Ex. H1, L1, V1 Returns ------- strain: pycbc.types.TimeSeries Strain around the event. """ from astropy.utils.data import download_file from pycbc.frame import read_frame # Information is currently wrong on GWOSC! # channels = self.data['files']['FrameChannels'] # for channel in channels: # if ifo in channel: # break length = "{}sec".format(duration) if sample_rate == 4096: sampling = "4KHz" elif sample_rate == 16384: sampling = "16KHz" channel = "{}:GWOSC-{}_R1_STRAIN".format(ifo, sampling.upper()) url = self.data['files'][ifo][length][sampling]['GWF'] filename = download_file(url, cache=True) return read_frame(str(filename), str(channel))
def get_swstat_bits(frame_filenames, swstat_channel_name, start_time, end_time): ''' This function just checks the first time in the SWSTAT channel to see if the filter was on, it doesn't check times beyond that. This is just for a first test on a small chunck of data. To read the SWSTAT bits, reference: https://dcc.ligo.org/DocDB/0107/T1300711/001/LIGO-T1300711-v1.pdf Bit 0-9 = Filter on/off switches for the 10 filters in an SFM. Bit 10 = Filter module input switch on/off Bit 11 = Filter module offset switch on/off Bit 12 = Filter module output switch on/off Bit 13 = Filter module limit switch on/off Bit 14 = Filter module history reset momentary switch ''' # read frames swstat = frame.read_frame(frame_filenames, swstat_channel_name, start_time=start_time, end_time=end_time) # convert number in channel to binary bits = bin(int(swstat[0])) # check if filterbank input or output was off filterbank_off = False if len(bits) < 14 or int(bits[-13]) == 0 or int(bits[-11]) == 0: filterbank_off = True return bits[-10:], filterbank_off
def strain(self, ifo, duration=32, sample_rate=4096): """ Return strain around the event Currently this will return the strain around the event in the smallest format available. Selection of other data is not yet available. Parameters ---------- ifo: str The name of the observatory you want strain for. Ex. H1, L1, V1 Returns ------- strain: pycbc.types.TimeSeries Strain around the event. """ from astropy.utils.data import download_file from pycbc.frame import read_frame # Information is currently wrong on GWOSC! # channels = self.data['files']['FrameChannels'] # for channel in channels: # if ifo in channel: # break length = "{}sec".format(duration) if sample_rate == 4096: sampling = "4KHz" elif sample_rate == 16384: sampling = "16KHz" channel = "{}:GWOSC-{}_R1_STRAIN".format(ifo, sampling.upper()) url = self.data['files'][ifo][length][sampling]['GWF'] filename = download_file(url, cache=True) return read_frame(str(filename), str(channel))
def setUp(self): ###### Get data for references analysis of 170817 m = Merger("GW170817") ifos = ['H1', 'V1', 'L1'] self.psds = {} self.data = {} for ifo in ifos: print("Processing {} data".format(ifo)) # Download the gravitational wave data for GW170817 url = "https://dcc.ligo.org/public/0146/P1700349/001/" url += "{}-{}1_LOSC_CLN_4_V1-1187007040-2048.gwf" fname = download_file(url.format(ifo[0], ifo[0]), cache=True) ts = read_frame(fname, "{}:LOSC-STRAIN".format(ifo), start_time=int(m.time - 260), end_time=int(m.time + 40)) ts = highpass(ts, 15.0) ts = resample_to_delta_t(ts, 1.0 / 2048) ts = ts.time_slice(m.time - 112, m.time + 16) self.data[ifo] = ts.to_frequencyseries() psd = interpolate(ts.psd(4), ts.delta_f) psd = inverse_spectrum_truncation(psd, int(4 * psd.sample_rate), trunc_method='hann', low_frequency_cutoff=20.0) self.psds[ifo] = psd self.static = { 'mass1': 1.3757, 'mass2': 1.3757, 'f_lower': 20.0, 'approximant': "TaylorF2", 'polarization': 0, 'ra': 3.44615914, 'dec': -0.40808407, 'tc': 1187008882.42840, } self.variable = ( 'distance', 'inclination', ) self.flow = {'H1': 25, 'L1': 25, 'V1': 25} inclination_prior = SinAngle(inclination=None) distance_prior = Uniform(distance=(10, 100)) tc_prior = Uniform(tc=(m.time - 0.1, m.time + 0.1)) self.prior = JointDistribution(self.variable, inclination_prior, distance_prior) ###### Expected answers # Answer taken from marginalized gaussian model self.q1 = {'distance': 42.0, 'inclination': 2.5} self.a1 = 541.8235746138382 # answer taken from brute marginize pol + phase self.a2 = 542.581 self.pol_samples = 200
def read_gain_from_frames(frame_filenames, gain_channel_name, start_time, end_time): ''' Returns the gain from the file. ''' # get timeseries from frame gain = frame.read_frame(frame_filenames, gain_channel_name, start_time=start_time, end_time=end_time) return gain[0]
def read_gain_from_frames(frame_filenames, gain_channel_name, start_time, end_time): ''' Returns the gain from the file. ''' # get timeseries from frame gain = frame.read_frame(frame_filenames, gain_channel_name, start_time=start_time, end_time=end_time) return gain[0]
def get_GWSC_Full_strain(pth, tstart, tend): """This function, require the strain .gwf name, without the detector definition (H-H1,L-L1), and loads the entire frame file downloaded from GW OSC, applies a high-pass filter at 15 Hz, then return the whole data without cutting that """ strain = {} for ifo in ifos: fname = '%s-%s_%s' % (ifo[0], ifo, pth) channel_name = '%s:GWOSC-4KHZ_R1_STRAIN' % ifo strain[ifo] = read_frame(fname, channel_name, tstart, tend) strain[ifo] = highpass(strain[ifo], 15.0) return strain
def get_strain_from_gwf_files( gwf_files: Dict[str, List[Union[str, bytes, os.PathLike]]], gps_start: int, window: int, original_sampling_rate: int = 4096, target_sampling_rate: int = 4096, as_pycbc_timeseries: bool = True, channel: str = 'GDS-CALIB_STRAIN', check_integrity: bool = True, ): assert isinstance(gps_start, int), 'time is not an int' assert isinstance(window, int), 'interval_width is not an int' assert isinstance(original_sampling_rate, int), 'original_sampling_rate is not an int' assert isinstance(target_sampling_rate, int), 'target_sampling_rate is not an int' assert (original_sampling_rate % target_sampling_rate) == 0, ( 'Invalid target_sampling_rate: Not a divisor of original_sampling_rate!' ) sampling_factor = int(original_sampling_rate / target_sampling_rate) samples = defaultdict(list) for ifo in gwf_files: detector_channel = f'{ifo}:{channel}' for file_path in gwf_files[ifo]: strain = read_frame( str(file_path), detector_channel, start_time=gps_start, end_time=gps_start + window, check_integrity=check_integrity, ) samples[ifo].append(strain[::sampling_factor]) samples[ifo] = np.ascontiguousarray(np.concatenate(samples[ifo])) if not as_pycbc_timeseries: return samples else: # Convert strain of both detectors to a TimeSeries object timeseries = { ifo: TimeSeries(initial_array=samples[ifo], delta_t=1.0 / target_sampling_rate, epoch=LIGOTimeGPS(gps_start)) for ifo in samples } return timeseries
def get_raw_strain(window=512): """This function loads the entire frame file downloaded from GW OSC, applies a high-pass filter at 15 Hz, then keeps the data around ``event_time`` +/-``window``. The ``event_time`` is from above; the default window is 512 (s). """ strain = {} for ifo in ifos: fname = '%s-%s_LOSC_4_V2-1126257414-4096.gwf' % (ifo[0], ifo) channel_name = '%s:LOSC-STRAIN' % ifo strain[ifo] = read_frame(fname, channel_name) strain[ifo] = highpass(strain[ifo], 15.0) strain[ifo] = strain[ifo].time_slice(event_time-window/2, event_time+window/2) return strain
def get_LSC_NoNan_strain(pth, tev, tstart, tend, window): """This function, require the strain .gwf name, without the detector definition (H-H1,L-L1), and loads the entire frame file downloaded from GW OSC, applies a high-pass filter at 15 Hz, then keeps the data around ``event_time`` +/-``window``. The ``event_time`` is from above; the default window is 512 (s). """ strain = {} for ifo in ifos: fname = '%s-%s_%s' % (ifo[0], ifo, pth) channel_name = '%s:LOSC-STRAIN' % ifo strain[ifo] = read_frame(fname, channel_name, tstart, tend) strain[ifo] = highpass(strain[ifo], 15.0) strain[ifo] = strain[ifo].time_slice(tev - window / 2, tev + window / 2) return strain
def get_raw_strain(window=198): """This function loads the entire frame file downloaded from GW OSC, applies a high-pass filter at 15 Hz, then keeps the data around ``event_time`` +/-``window``. The ``event_time`` is from above; the default window is 512 (s). """ #Here I have changed: _LOSC_4_V2-1126257414-4096.gwf to _GWOSC_4KHZ_R1-1135134303-4096.gwf (i.e. the data_file name) #LOSC-STRAIN was changed as well to GWOSC-4KHZ_R1_STRAIN strain = {} for ifo in ifos: fname = '%s-%s_GWOSC_4KHZ_R1-1135134303-4096.gwf' % (ifo[0], ifo) channel_name = '%s:GWOSC-4KHZ_R1_STRAIN' % ifo strain[ifo] = read_frame(fname, channel_name) strain[ifo] = strain[ifo].time_slice(event_time - window / 2, event_time + window / 2) #strain[ifo] = highpass(strain[ifo], 15.0) return strain
def read_frame_losc(channels, start_time, end_time): """ Read channels from losc data Parameters ---------- channels: str or list The channel name to read or list of channel names. start_time: int The gps time in GPS seconds end_time: int The end time in GPS seconds Returns ------- ts: TimeSeries Returns a timeseries or list of timeseries with the requested data. """ import urllib from pycbc.frame import read_frame if not isinstance(channels, list): channels = [channels] ifos = [c[0:2] for c in channels] urls = {} for ifo in ifos: urls[ifo] = losc_frame_urls(ifo, start_time, end_time) if len(urls[ifo]) == 0: raise ValueError("No data found for %s so we " "can't produce a time series" % ifo) fnames = {ifo: [] for ifo in ifos} for ifo in ifos: for url in urls[ifo]: fname, _ = urllib.urlretrieve(url) fnames[ifo].append(fname) ts = [ read_frame(fnames[channel[0:2]], channel, start_time=start_time, end_time=end_time) for channel in channels ] if len(ts) == 1: return ts[0] else: return ts
def plot_gwfs( frame_location1, frame_location2, label=['frame1','frame2'] ): # import matplotlib as mpl mpl.rc('font',family='Times New Roman') from matplotlib.pyplot import plot,xlabel,ylabel,figure,legend,xlim,ylim,title from pycbc import frame import numpy # frame_location = [frame_location1,frame_location2] # figure( figsize=0.8*numpy.array([16,4]) ) clrspec = [ 'b', [0.8,0.8,0.8] ] widspec = [ 1, 3 ] for k in [1,0]: # data_L = frame.read_frame( frame_location[k], '%s1:HWINJ_INJECTED'%frame_location[k][0] ) # trigger_time = data_L.end_time.gpsSeconds-10.0 time = data_L.delta_t * (numpy.array(range(len(data_L.data)))-1.0) + data_L.start_time - trigger_time #channel_data_H = data_H.data.real channel_data_L = data_L.data.real # xlim( numpy.array([-0.18,0.18]) ) #plot( time, channel_data_H, color=0.7*numpy.array([1,1,1]) ) # plot( time, channel_data_L, color=0.8*numpy.array([numpy.sin(numpy.pi/(k+1)),1,1]), label=label[k] ) plot( time, channel_data_L, color=clrspec[k], label=label[k], linewidth=widspec[k] ) #plot( trigger_time * numpy.array([1,1]) , ylim(), color='r' ) fs=22 hfont = {'fontname':'serif'} title(frame_location[k][0]+'1') xlabel(r'$t$ (sec)', fontsize=fs) ylabel(r'$h(t)$', fontsize=fs) legend(frameon=False, fontsize=fs )
def read_frame_losc(channels, start_time, end_time): """ Read channels from losc data Parameters ---------- channels: str or list The channel name to read or list of channel names. start_time: int The gps time in GPS seconds end_time: int The end time in GPS seconds Returns ------- ts: TimeSeries Returns a timeseries or list of timeseries with the requested data. """ import urllib from pycbc.frame import read_frame if not isinstance(channels, list): channels = [channels] ifos = [c[0:2] for c in channels] urls = {} for ifo in ifos: urls[ifo] = losc_frame_urls(ifo, start_time, end_time) if len(urls[ifo]) == 0: raise ValueError("No data found for %s so we " "can't produce a time series" % ifo) fnames = {ifo:[] for ifo in ifos} for ifo in ifos: for url in urls[ifo]: fname, _ = urllib.urlretrieve(url) fnames[ifo].append(fname) ts = [read_frame(fnames[channel[0:2]], channel, start_time=start_time, end_time=end_time) for channel in channels] if len(ts) == 1: return ts[0] else: return ts
def strain(self, ifo): """ Return strain around the event Currently this will return the strain around the event in the smallest format available. Selection of other data is not yet available. Parameters ---------- ifo: str The name of the observatory you want strain for. Ex. H1, L1, V1 Returns ------- strain: pycbc.types.TimeSeries Strain around the event. """ from astropy.utils.data import download_file from pycbc.frame import read_frame channel = '%s:LOSC-STRAIN' % ifo url = self.data['frames'][ifo] filename = download_file(url, cache=True) return read_frame(filename, channel)
def strain(self, ifo, duration=32, sample_rate=4096): """ Return strain around the event Currently this will return the strain around the event in the smallest format available. Selection of other data is not yet available. Parameters ---------- ifo: str The name of the observatory you want strain for. Ex. H1, L1, V1 Returns ------- strain: pycbc.types.TimeSeries Strain around the event. """ from pycbc.io import get_file from pycbc.frame import read_frame for fdict in self.data['strain']: if (fdict['detector'] == ifo and fdict['duration'] == duration and fdict['sampling_rate'] == sample_rate and fdict['format'] == 'gwf'): url = fdict['url'] break else: raise ValueError('no strain data is available as requested ' 'for ' + self.common_name) ver = url.split('/')[-1].split('-')[1].split('_')[-1] sampling_map = {4096: "4KHZ", 16384: "16KHZ"} channel = "{}:GWOSC-{}_{}_STRAIN".format(ifo, sampling_map[sample_rate], ver) filename = get_file(url, cache=True) return read_frame(str(filename), str(channel))
from pycbc.frame import read_frame from pycbc.filter import highpass_fir, matched_filter from pycbc.waveform import get_fd_waveform from pycbc.psd import welch, interpolate import urllib # Read data and remove low frequency content fname = 'H-H1_LOSC_4_V2-1126259446-32.gwf' url = "https://www.gw-openscience.org/GW150914data/" + fname urllib.urlretrieve(url, filename=fname) h1 = read_frame('H-H1_LOSC_4_V2-1126259446-32.gwf', 'H1:LOSC-STRAIN') h1 = highpass_fir(h1, 15, 8) # Calculate the noise spectrum psd = interpolate(welch(h1), 1.0 / h1.duration) # Generate a template to filter with hp, hc = get_fd_waveform(approximant="IMRPhenomD", mass1=40, mass2=32, f_lower=20, delta_f=1.0 / h1.duration) hp.resize(len(h1) / 2 + 1) # Calculate the complex (two-phase SNR) snr = matched_filter(hp, h1, psd=psd, low_frequency_cutoff=20.0) # Remove regions corrupted by filter wraparound snr = snr[len(snr) / 4:len(snr) * 3 / 4] import pylab
from pycbc.frame import read_frame from pycbc.filter import highpass_fir, matched_filter from pycbc.waveform import get_fd_waveform from pycbc.psd import welch, interpolate import urllib # Read data and remove low frequency content fname = 'H-H1_LOSC_4_V2-1126259446-32.gwf' url = "https://losc.ligo.org/s/events/GW150914/" + fname urllib.urlretrieve(url, filename=fname) h1 = read_frame('H-H1_LOSC_4_V2-1126259446-32.gwf', 'H1:LOSC-STRAIN') h1 = highpass_fir(h1, 15, 8) # Calculate the noise spectrum psd = interpolate(welch(h1), 1.0 / 32) # Generate a template to filter with hp, hc = get_fd_waveform(approximant="IMRPhenomD", mass1=40, mass2=32, f_lower=20, delta_f=1.0/32) hp.resize(len(h1) / 2 + 1) # Calculate the complex (two-phase SNR) snr = matched_filter(hp, h1, psd=psd, low_frequency_cutoff=20.0) # Remove regions corrupted by filter wraparound snr = snr[len(snr) / 4: len(snr) * 3 / 4] import pylab pylab.plot(snr.sample_times, abs(snr)) pylab.ylabel('signal-to-noise') pylab.xlabel('GPS Time (s)')
from scipy import signal import matplotlib.pyplot as plt from pycbc.frame import read_frame file_name = "H-H1_GWOSC_16KHZ_R1-1187008867-32.gwf" merger = 1187008882.4 # LOSC bulk data typically uses the same convention for internal channels names # Strain is typically IFO:LOSC-STRAIN, where IFO can be H1/L1/V1. channel_name = "H1:GWOSC-16KHZ_R1_STRAIN" hc = 500 lc = 30 ts = read_frame(file_name, channel_name, 1187008867, 1187008867 + 32) start = ts.start_time ts = ts.highpass_fir(lc, 512) ts = ts.lowpass_fir(hc, 512) strain = ts.data psd = ts.psd(2) whitened = ts.whiten(4, 4, low_frequency_cutoff=20) fs = 10e3 N = 1e5 amp = 2 * np.sqrt(2)
def from_cli(opt, dyn_range_fac=1, precision='single'): """Parses the CLI options related to strain data reading and conditioning. Parameters ---------- opt : object Result of parsing the CLI with OptionParser, or any object with the required attributes (gps-start-time, gps-end-time, strain-high-pass, pad-data, sample-rate, (frame-cache or frame-files), channel-name, fake-strain, fake-strain-seed, gating_file). dyn_range_fac: {float, 1}, optional A large constant to reduce the dynamic range of the strain. Returns ------- strain : TimeSeries The time series containing the conditioned strain data. """ gating_info = {} if opt.frame_cache or opt.frame_files or opt.frame_type: if opt.frame_cache: frame_source = opt.frame_cache if opt.frame_files: frame_source = opt.frame_files logging.info("Reading Frames") if opt.frame_type: strain = query_and_read_frame(opt.frame_type, opt.channel_name, start_time=opt.gps_start_time-opt.pad_data, end_time=opt.gps_end_time+opt.pad_data) else: strain = read_frame(frame_source, opt.channel_name, start_time=opt.gps_start_time-opt.pad_data, end_time=opt.gps_end_time+opt.pad_data) if opt.zpk_z and opt.zpk_p and opt.zpk_k: logging.info("Highpass Filtering") strain = highpass(strain, frequency=opt.strain_high_pass) logging.info("Applying zpk filter") z = numpy.array(opt.zpk_z) p = numpy.array(opt.zpk_p) k = float(opt.zpk_k) strain = filter_zpk(strain.astype(numpy.float64), z, p, k) if opt.normalize_strain: logging.info("Dividing strain by constant") l = opt.normalize_strain strain = strain / l if opt.injection_file: logging.info("Applying injections") injections = InjectionSet(opt.injection_file) injections.apply(strain, opt.channel_name[0:2], distance_scale=opt.injection_scale_factor) if opt.sgburst_injection_file: logging.info("Applying sine-Gaussian burst injections") injections = SGBurstInjectionSet(opt.sgburst_injection_file) injections.apply(strain, opt.channel_name[0:2], distance_scale=opt.injection_scale_factor) logging.info("Highpass Filtering") strain = highpass(strain, frequency=opt.strain_high_pass) if precision == 'single': logging.info("Converting to float32") strain = (strain * dyn_range_fac).astype(float32) if opt.gating_file is not None: logging.info("Gating glitches") gate_params = numpy.loadtxt(opt.gating_file) if len(gate_params.shape) == 1: gate_params = [gate_params] strain = gate_data(strain, gate_params) gating_info['file'] = \ [gp for gp in gate_params \ if (gp[0] + gp[1] + gp[2] >= strain.start_time) \ and (gp[0] - gp[1] - gp[2] <= strain.end_time)] if opt.autogating_threshold is not None: # the + 0 is for making a copy glitch_times = detect_loud_glitches( strain + 0., threshold=opt.autogating_threshold, cluster_window=opt.autogating_cluster, low_freq_cutoff=opt.strain_high_pass, high_freq_cutoff=opt.sample_rate/2, corrupted_time=opt.pad_data+opt.autogating_pad) gate_params = [[gt, opt.autogating_width, opt.autogating_taper] \ for gt in glitch_times] if len(glitch_times) > 0: logging.info('Autogating at %s', ', '.join(['%.3f' % gt for gt in glitch_times])) strain = gate_data(strain, gate_params) gating_info['auto'] = gate_params logging.info("Resampling data") strain = resample_to_delta_t(strain, 1.0/opt.sample_rate, method='ldas') logging.info("Highpass Filtering") strain = highpass(strain, frequency=opt.strain_high_pass) logging.info("Remove Padding") start = opt.pad_data*opt.sample_rate end = len(strain)-opt.sample_rate*opt.pad_data strain = strain[start:end] if opt.fake_strain: logging.info("Generating Fake Strain") duration = opt.gps_end_time - opt.gps_start_time tlen = duration * opt.sample_rate pdf = 1.0/128 plen = int(opt.sample_rate / pdf) / 2 + 1 logging.info("Making PSD for strain") strain_psd = pycbc.psd.from_string(opt.fake_strain, plen, pdf, opt.low_frequency_cutoff) logging.info("Making colored noise") strain = pycbc.noise.noise_from_psd(tlen, 1.0/opt.sample_rate, strain_psd, seed=opt.fake_strain_seed) strain._epoch = lal.LIGOTimeGPS(opt.gps_start_time) if opt.injection_file: logging.info("Applying injections") injections = InjectionSet(opt.injection_file) injections.apply(strain, opt.channel_name[0:2], distance_scale=opt.injection_scale_factor) if opt.sgburst_injection_file: logging.info("Applying sine-Gaussian burst injections") injections = SGBurstInjectionSet(opt.sgburst_injection_file) injections.apply(strain, opt.channel_name[0:2], distance_scale=opt.injection_scale_factor) if precision == 'single': logging.info("Converting to float32") strain = (dyn_range_fac * strain).astype(float32) if opt.injection_file or opt.sgburst_injection_file: strain.injections = injections strain.gating_info = gating_info return strain
import pylab import numpy from pycbc.frame import read_frame from pycbc.types import load_timeseries lal_out_file = "H1-INSPIRAL_lalsuite_FULL_DATA-968605000-2048.gwf" # Take only the first 16 seconds to use as a small comparison lal_raw = read_frame(lal_out_file, 'H1:LDAS-STRAIN_RAW', start_time=968605000, duration="16") lal_resample = read_frame(lal_out_file, 'H1:LDAS-STRAIN_RAW_RESAMP', start_time=968605000, duration="16") lal_conditioned = read_frame(lal_out_file, 'H1:LDAS-STRAIN_FILTER', start_time=968605000, duration="16") # Take only the first 16 seconds to use as a small comparison start_offset = 8 # This is the offest between the output that PyCBC gives and lalapps_inspiral # lalapps_inspiral does not output the 8 second padding in the frame file pycbc_raw = load_timeseries("raw_pycbc.npy")[start_offset*16384:(start_offset+16)*16384].astype(lal_raw.dtype) pycbc_resample = load_timeseries("resampled_pycbc.npy")[start_offset*4096:(start_offset+16)*4096].astype(lal_raw.dtype) # the lalapps_inspiral gwf file misreportes the epoch for some of the streams pycbc_conditioned = load_timeseries("conditioned_pycbc.npy")[start_offset*4096:(start_offset+16)*4096].astype(lal_raw.dtype) pycbc_conditioned._epoch = lal_conditioned._epoch print float(pycbc_conditioned.start_time) def p(a, b, an, bn): t = numpy.arange(0, len(a), 1) mindif = 1e-7 pylab.figure() pylab.scatter(t, a, label=an, color="red", marker='x') pylab.scatter(t, b, label=bn, color="blue", marker='+')
def get_noise(detector): import pycbc.frame as frame import random as randi import os h1_list = [ 'H-H1_LOSC_16_V1-1126084608-4096.gwf', 'H-H1_LOSC_16_V1-1126109184-4096.gwf', 'H-H1_LOSC_16_V1-1126264832-4096.gwf', 'H-H1_LOSC_16_V1-1126293504-4096.gwf', 'H-H1_LOSC_16_V1-1127194624-4096.gwf', 'H-H1_LOSC_16_V1-1128042496-4096.gwf', 'H-H1_LOSC_16_V1-1128345600-4096.gwf', 'H-H1_LOSC_16_V1-1128407040-4096.gwf', 'H-H1_LOSC_16_V1-1128624128-4096.gwf', 'H-H1_LOSC_16_V1-1128665088-4096.gwf', 'H-H1_LOSC_16_V1-1129127936-4096.gwf', 'H-H1_LOSC_16_V1-1129664512-4096.gwf' ] h1_begin = [ 1126084608, 1126109184, 1126264832, 1126293504, 1127194624, 1128042496, 1128345600, 1128407040, 1128624128, 1128665088, 1129127936, 1129664512 ] l1_list = [ 'L-L1_LOSC_16_V1-1126088704-4096.gwf', 'L-L1_LOSC_16_V1-1126105088-4096.gwf', 'L-L1_LOSC_16_V1-1127018496-4096.gwf', 'L-L1_LOSC_16_V1-1127022592-4096.gwf', 'L-L1_LOSC_16_V1-1127030784-4096.gwf', 'L-L1_LOSC_16_V1-1127051264-4096.gwf', 'L-L1_LOSC_16_V1-1127059456-4096.gwf', 'L-L1_LOSC_16_V1-1127096320-4096.gwf', 'L-L1_LOSC_16_V1-1129521152-4096.gwf', 'L-L1_LOSC_16_V1-1134870528-4096.gwf', 'L-L1_LOSC_16_V1-1136615424-4096.gwf', 'L-L1_LOSC_16_V1-1136631808-4096.gwf' ] l1_begin = [ 1126088704, 1126105088, 1127018496, 1127022592, 1127030784, 1127051264, 1127059456, 1127096320, 1129521152, 1134870528, 1136615424, 1136631808 ] if detector == 'O1-H': file_index = randi.randrange(1, 12, 1) print file_index a = h1_begin[file_index] print a start_time = randi.randrange(a, a + 4054, 1) print start_time file = h1_list[file_index] print file strain = frame.read_frame(file, 'H1:GWOSC-16KHZ_R1_STRAIN') elif detector == 'O1-L': a = l1_begin[file_index] print a file_index = randi.randrange(1, 12, 1) print file_index start_time = randi.randrange(a, l1_begin[file_index] + 4054, 1) print start_time file = l1_list[file_index] strain = frame.read_frame(file, 'L1:GWOSC-16KHZ_R1_STRAIN', start_time, start_time + 32) shift = randi.randrange(5, 27, 1) return strain, shift
from pycbc.frame import read_frame from pycbc.filter import highpass_fir, lowpass_fir, matched_filter from pycbc.waveform import get_fd_waveform from pycbc.psd import welch, interpolate import urllib import pylab for ifo in ['H1', 'L1']: # Read data and remove low frequency content fname = '%s-%s_LOSC_4_V2-1126259446-32.gwf' % (ifo[0], ifo) url = "https://losc.ligo.org/s/events/GW150914/" + fname urllib.urlretrieve(url, filename=fname) h1 = read_frame(fname, '%s:LOSC-STRAIN' % ifo) h1 = highpass_fir(h1, 15, 8) # Calculate the noise spectrum psd = interpolate(welch(h1), 1.0 / h1.duration) # whiten white_strain = (h1.to_frequencyseries() / psd**0.5 * psd.delta_f).to_timeseries() # remove some of the high and low smooth = highpass_fir(white_strain, 35, 8) smooth = lowpass_fir(white_strain, 300, 8) # time shift and flip L1 if ifo == 'L1': smooth *= -1 smooth.roll(int(.007 / smooth.delta_t))
from pycbc.frame import read_frame from pycbc.filter import highpass_fir, lowpass_fir, matched_filter from pycbc.waveform import get_fd_waveform from pycbc.psd import welch, interpolate import urllib import pylab for ifo in ['H1', 'L1']: # Read data and remove low frequency content fname = '%s-%s_LOSC_4_V2-1126259446-32.gwf' % (ifo[0], ifo) url = "https://losc.ligo.org/s/events/GW150914/" + fname urllib.urlretrieve(url, filename=fname) h1 = read_frame(fname, '%s:LOSC-STRAIN' % ifo) h1 = highpass_fir(h1, 15, 8) # Calculate the noise spectrum psd = interpolate(welch(h1), 1.0 / h1.duration) # whiten white_strain = (h1.to_frequencyseries() / psd ** 0.5 * psd.delta_f).to_timeseries() # remove some of the high and low smooth = highpass_fir(white_strain, 35, 8) smooth = lowpass_fir(white_strain, 300, 8) # time shift and flip L1 if ifo == 'L1': smooth *= -1 smooth.roll(int(.007 / smooth.delta_t)) pylab.plot(smooth.sample_times, smooth, label=ifo)
def principal(runs,archivo_nombre,local,ifo,hilo): # Loading our modules from modulos import gw_resample, gw_injection, gw_matched_filter from modulos import gw_detection, gw_expected, gw_qtransform, gw_data, gw_chisqv2, gw_readtemplatev from Noise_Sources import gw_load_noise, load import numpy as np import random as randi from pycbc import frame, types import urllib grafica = 0 SNRthr = 5.5 NSegmnt = 128 #initial distance i_d = 1 #final distance f_d = 10 #number of slices N_d = 128 #dic = np.linspace(i_d,f_d,N_d) #di = [] #di = [1,5,10,15,20,25,30,35,40,45,50] #di.extend(dic) if local == False: url = 'https://www.gw-openscience.org/archive/data/O1_16KHZ/1126170624/'+ifo+'-'+ifo+'1_LOSC_16_V1-' urllib.urlretrieve(url+str(archivo_nombre)+'-4096.gwf', str(archivo_nombre)+'.gwf') #------------------------------------------------------------------------- #temporal stuff aprox = 'NEW' numero = 1 total_time = 32 fs = 8192 # Sampling frequency fs_ligo = 16384 #---------------------------------------------------------------------------# # loading files # #---------------------------------------------------------------------------# archivo = str(archivo_nombre)+'.gwf' strain_initial = frame.read_frame(archivo, 'H1:GWOSC-16KHZ_R1_STRAIN') strain_n = strain_initial.data del strain_initial strain_light = [] for i in range(NSegmnt): a = i * total_time * fs_ligo b = (i + 1) * total_time * fs_ligo strain_light.append(strain_n[a:b]) ############################################################################### # # vectores de resultados # ############################################################################### SNRrec = [] SNRexp = [] trigger_time = [] injection_time = [] total_flag = [] numero = 20 for i in range(numero): for dat in range(len(strain_light)): print dat, ' indice de segmento' strain = strain_light[dat] strain = types.TimeSeries(initial_array=strain, delta_t=1.0/fs_ligo , epoch=0) rec = [] exp = [] flag = [] tt = [] ti = [] assert isinstance(runs, object) # for d in range(len(di)): distancia = 3#di[d] n=numero print distancia, ' distancia' # Reading template h,dt,nombre = gw_readtemplatev.lectura(n,aprox) # Distance hh, dts,dtf = gw_resample.interpolacion(h,dt,grafica,fs) hh = hh/distancia shift = 28 template, noise = gw_resample.resampleado(strain,hh,grafica,fs,fs_ligo) # Making uniform the distribution of the dt in the template # These function returns the resampled strain, #Resampling and resizing data # Making the injection of the template into the data strain_inj,tmax,injection_shift = gw_injection.make(noise,template,shift,grafica) # The limit values for the frequency in the filters fc = 15 hc = 1200 mc = 733 # Making the matched filter # This function give us the timeseries object of the snr over the time, the maximum value of the snr and # the time that it occurs snr,psd,index_snr_trigger,time,rho,psd_o,rho_0 = gw_matched_filter.make(strain_inj,template,fc,mc,hc,grafica) # Getting the Chi^2 value snr2,HSNR2_time,nsnr = gw_chisqv2.xis(snr,template,strain_inj,psd_o,fc,grafica,time,dtf,hc,shift,index_snr_trigger) # Getting the theoretical value of snr #------------------------------------------------------------------------------------------------------------------------- # Detection part desicion = gw_detection.decision(rho,SNRthr) #-------------------------------------------------------------------------------------------------------------------------- # The time, amplitude, and phase of the SNR peak tell us how to align # our proposed signal with the data. rec.append(abs(rho)) exp.append(abs(rho_0)) flag.append(desicion) tt.append(shift) ti.append(time) SNRrec.extend(rec) SNRexp.extend(exp) total_flag.extend(flag) trigger_time.extend(ti) injection_time.extend(tt) rec = [] exp = [] flag = [] tt = [] ti = [] np.savetxt('Total'+str(archivo_nombre)+ifo+'Hilo'+hilo+'.out',(SNRrec,SNRexp,total_flag,trigger_time,injection_time),fmt='%3.2f') return
def from_cli(opt, dyn_range_fac=1, precision='single'): """Parses the CLI options related to strain data reading and conditioning. Parameters ---------- opt : object Result of parsing the CLI with OptionParser, or any object with the required attributes (gps-start-time, gps-end-time, strain-high-pass, pad-data, sample-rate, (frame-cache or frame-files), channel-name, fake-strain, fake-strain-seed, gating_file). dyn_range_fac: {float, 1}, optional A large constant to reduce the dynamic range of the strain. Returns ------- strain : TimeSeries The time series containing the conditioned strain data. """ if opt.frame_cache or opt.frame_files: if opt.frame_cache: frame_source = opt.frame_cache if opt.frame_files: frame_source = opt.frame_files logging.info("Reading Frames") strain = read_frame(frame_source, opt.channel_name, start_time=opt.gps_start_time-opt.pad_data, end_time=opt.gps_end_time+opt.pad_data) if opt.zpk_z and opt.zpk_p and opt.zpk_k: logging.info("Highpass Filtering") strain = highpass(strain, frequency=opt.strain_high_pass) logging.info("Applying zpk filter") z = numpy.array(opt.zpk_z) p = numpy.array(opt.zpk_p) k = float(opt.zpk_k) strain = filter_zpk(strain.astype(numpy.float64), z, p, k) if opt.normalize_strain: logging.info("Dividing strain by constant") l = opt.normalize_strain strain = strain / l if opt.injection_file: logging.info("Applying injections") injections = InjectionSet(opt.injection_file) injections.apply(strain, opt.channel_name[0:2]) if opt.sgburst_injection_file: logging.info("Applying sine-Gaussian burst injections") injections = SGBurstInjectionSet(opt.sgburst_injection_file) injections.apply(strain, opt.channel_name[0:2]) logging.info("Highpass Filtering") strain = highpass(strain, frequency=opt.strain_high_pass) if precision == 'single': logging.info("Converting to float32") strain = (strain * dyn_range_fac).astype(float32) if opt.gating_file is not None: logging.info("Gating glitches") gate_params = numpy.loadtxt(opt.gating_file) if len(gate_params.shape) == 1: gate_params = [gate_params] strain = gate_data( strain, gate_params, data_start_time=(opt.gps_start_time - opt.pad_data)) logging.info("Resampling data") strain = resample_to_delta_t(strain, 1.0/opt.sample_rate, method='ldas') logging.info("Highpass Filtering") strain = highpass(strain, frequency=opt.strain_high_pass) logging.info("Remove Padding") start = opt.pad_data*opt.sample_rate end = len(strain)-opt.sample_rate*opt.pad_data strain = strain[start:end] if opt.fake_strain: logging.info("Generating Fake Strain") duration = opt.gps_end_time - opt.gps_start_time tlen = duration * opt.sample_rate pdf = 1.0/128 plen = int(opt.sample_rate / pdf) / 2 + 1 logging.info("Making PSD for strain") strain_psd = psd.from_string(opt.fake_strain, plen, pdf, opt.low_frequency_cutoff) logging.info("Making colored noise") strain = pycbc.noise.noise_from_psd(tlen, 1.0/opt.sample_rate, strain_psd, seed=opt.fake_strain_seed) strain._epoch = lal.LIGOTimeGPS(opt.gps_start_time) if opt.injection_file: logging.info("Applying injections") injections = InjectionSet(opt.injection_file) injections.apply(strain, opt.channel_name[0:2]) if opt.sgburst_injection_file: logging.info("Applying sine-Gaussian burst injections") injections = SGBurstInjectionSet(opt.sgburst_injection_file) injections.apply(strain, opt.channel_name[0:2]) if precision == 'single': logging.info("Converting to float32") strain = (dyn_range_fac * strain).astype(float32) if opt.injection_file: strain.injections = injections return strain
type=int, help='Value of DQ vector indicating good data') parser.add_argument('--dq-bad-times', type=float, nargs='+', metavar='TIME', help='Center time(s) of bad DQ epoch(s)') parser.add_argument('--dq-bad-pad', type=float, help='Duration of bad DQ epoch(s)') args = parser.parse_args() # load frame file strain = read_frame(args.input_file, args.strain_channel) out_channel_names = [args.strain_channel] out_timeseries = [strain] # add state vector if args.state_vector is not None: state_dt = 1. / 16. state_size = int(strain.duration / state_dt) state_data = np.zeros(state_size, dtype=np.uint32) state_data[:] = args.state_vector_good state_ts = TimeSeries(state_data, delta_t=state_dt, epoch=strain.start_time)
from pycbc.frame import read_frame from pycbc.filter import highpass_fir, lowpass_fir from pycbc.psd import welch, interpolate from pycbc.types import TimeSeries import urllib # Read data and remove low frequency content fname = 'H-H1_LOSC_4_V2-1126259446-32.gwf' url = "https://losc.ligo.org/s/events/GW150914/" + fname urllib.urlretrieve(url, filename=fname) h1 = highpass_fir(read_frame(fname, 'H1:LOSC-STRAIN'), 15.0, 8) # Calculate the noise spectrum and whiten psd = interpolate(welch(h1), 1.0 / 32) white_strain = (h1.to_frequencyseries() / psd ** 0.5 * psd.delta_f).to_timeseries() # remove some of the high and low frequencies smooth = highpass_fir(white_strain, 25, 8) smooth = lowpass_fir(white_strain, 250, 8) #strech out and shift the frequency upwards to aid human hearing fdata = smooth.to_frequencyseries() fdata.roll(int(1200 / fdata.delta_f)) smooth = TimeSeries(fdata.to_timeseries(), delta_t=1.0/1024) #Take slice around signal smooth = smooth[len(smooth)/2 - 1500:len(smooth)/2 + 3000] smooth.save_to_wav('gw150914_h1_chirp.wav')
#!/usr/bin/env python import numpy as np from pycbc import frame from glob import glob import sys filename = glob('./*{0:s}.gwf'.format(sys.argv[1]))[0] data = frame.read_frame( filename, '{0:s}:HWINJ_INJECTED'.format(sys.argv[1])) idx_max = np.argmax(np.abs(data.numpy())) time = data.get_sample_times().numpy()[idx_max] with open('./time.txt', 'w+') as f: f.write('{0:.2f}'.format(time))
"""Pick the event with the code *GW170817*. We pick the time frame from 224 seconds before merging and end 32 seconds after merging.""" # Commented out IPython magic to ensure Python compatibility. # %matplotlib inline import pylab from pycbc.filter import highpass from pycbc.catalog import Merger from pycbc.frame import read_frame merger = Merger("GW170817") # the merging part of the event, event = two black holes merging and causing gravitational wave strain, stilde = {}, {} for ifo in ['L1', 'H1']: ts = read_frame("{}-{}_LOSC_CLN_4_V1-1187007040-2048.gwf".format(ifo[0], ifo), '{}:LOSC-STRAIN'.format(ifo), start_time=merger.time - 224, # merger.time = the time of merging end_time=merger.time + 32, check_integrity=False) """Cleaning and applying highpass filter. Downsample to 2048 Hz to make the data analysis more convenient. Power density of the noise is higher than the signal. At higher frequency the amplitude of the noise is lower. And then graph.""" from pycbc.catalog import Merger from pycbc.filter import resample_to_delta_t, highpass from pycbc.catalog import Merger from pycbc.filter import resample_to_delta_t, highpass merger = Merger("GW170817") strain, stilde = {}, {} # tuple of directories: strain and stilde=cleaned data for ifo in ['L1', 'H1']: # We'll download the data and select 256 seconds that includes the event time
import pylab import numpy from pycbc.frame import read_frame from pycbc.types import load_timeseries lal_out_file = "H1-INSPIRAL_lalsuite_FULL_DATA-968605000-2048.gwf" # Take only the first 16 seconds to use as a small comparison lal_raw = read_frame(lal_out_file, 'H1:LDAS-STRAIN_RAW', start_time=968605000, duration="16") lal_resample = read_frame(lal_out_file, 'H1:LDAS-STRAIN_RAW_RESAMP', start_time=968605000, duration="16") lal_conditioned = read_frame(lal_out_file, 'H1:LDAS-STRAIN_FILTER', start_time=968605000, duration="16") # Take only the first 16 seconds to use as a small comparison start_offset = 8 # This is the offest between the output that PyCBC gives and lalapps_inspiral # lalapps_inspiral does not output the 8 second padding in the frame file pycbc_raw = load_timeseries("raw_pycbc.npy")[start_offset * 16384:(start_offset + 16) * 16384].astype(lal_raw.dtype) pycbc_resample = load_timeseries( "resampled_pycbc.npy")[start_offset * 4096:(start_offset + 16) * 4096].astype(lal_raw.dtype)
def from_cli(opt, dyn_range_fac=1, precision='single'): """Parses the CLI options related to strain data reading and conditioning. Parameters ---------- opt : object Result of parsing the CLI with OptionParser, or any object with the required attributes (gps-start-time, gps-end-time, strain-high-pass, pad-data, sample-rate, (frame-cache or frame-files), channel-name, fake-strain, fake-strain-seed, gating_file). dyn_range_fac: {float, 1}, optional A large constant to reduce the dynamic range of the strain. Returns ------- strain : TimeSeries The time series containing the conditioned strain data. """ gating_info = {} if opt.frame_cache or opt.frame_files or opt.frame_type: if opt.frame_cache: frame_source = opt.frame_cache if opt.frame_files: frame_source = opt.frame_files logging.info("Reading Frames") if opt.frame_type: strain = query_and_read_frame(opt.frame_type, opt.channel_name, start_time=opt.gps_start_time-opt.pad_data, end_time=opt.gps_end_time+opt.pad_data) else: strain = read_frame(frame_source, opt.channel_name, start_time=opt.gps_start_time-opt.pad_data, end_time=opt.gps_end_time+opt.pad_data) if opt.zpk_z and opt.zpk_p and opt.zpk_k: logging.info("Highpass Filtering") strain = highpass(strain, frequency=opt.strain_high_pass) logging.info("Applying zpk filter") z = numpy.array(opt.zpk_z) p = numpy.array(opt.zpk_p) k = float(opt.zpk_k) strain = filter_zpk(strain.astype(numpy.float64), z, p, k) if opt.normalize_strain: logging.info("Dividing strain by constant") l = opt.normalize_strain strain = strain / l if opt.injection_file: logging.info("Applying injections") injections = InjectionSet(opt.injection_file) injections.apply(strain, opt.channel_name[0:2], distance_scale=opt.injection_scale_factor) if opt.sgburst_injection_file: logging.info("Applying sine-Gaussian burst injections") injections = SGBurstInjectionSet(opt.sgburst_injection_file) injections.apply(strain, opt.channel_name[0:2], distance_scale=opt.injection_scale_factor) logging.info("Highpass Filtering") strain = highpass(strain, frequency=opt.strain_high_pass) if precision == 'single': logging.info("Converting to float32") strain = (strain * dyn_range_fac).astype(pycbc.types.float32) if opt.gating_file is not None: logging.info("Gating glitches") gate_params = numpy.loadtxt(opt.gating_file) if len(gate_params.shape) == 1: gate_params = [gate_params] strain = gate_data(strain, gate_params) gating_info['file'] = \ [gp for gp in gate_params \ if (gp[0] + gp[1] + gp[2] >= strain.start_time) \ and (gp[0] - gp[1] - gp[2] <= strain.end_time)] if opt.autogating_threshold is not None: # the + 0 is for making a copy glitch_times = detect_loud_glitches( strain + 0., threshold=opt.autogating_threshold, cluster_window=opt.autogating_cluster, low_freq_cutoff=opt.strain_high_pass, high_freq_cutoff=opt.sample_rate/2, corrupt_time=opt.pad_data+opt.autogating_pad) gate_params = [[gt, opt.autogating_width, opt.autogating_taper] \ for gt in glitch_times] if len(glitch_times) > 0: logging.info('Autogating at %s', ', '.join(['%.3f' % gt for gt in glitch_times])) strain = gate_data(strain, gate_params) gating_info['auto'] = gate_params logging.info("Resampling data") strain = resample_to_delta_t(strain, 1.0/opt.sample_rate, method='ldas') logging.info("Highpass Filtering") strain = highpass(strain, frequency=opt.strain_high_pass) logging.info("Remove Padding") start = opt.pad_data*opt.sample_rate end = len(strain)-opt.sample_rate*opt.pad_data strain = strain[start:end] if opt.fake_strain: logging.info("Generating Fake Strain") duration = opt.gps_end_time - opt.gps_start_time tlen = duration * opt.sample_rate pdf = 1.0/128 plen = int(opt.sample_rate / pdf) / 2 + 1 logging.info("Making PSD for strain") strain_psd = pycbc.psd.from_string(opt.fake_strain, plen, pdf, opt.low_frequency_cutoff) logging.info("Making colored noise") strain = pycbc.noise.noise_from_psd(tlen, 1.0/opt.sample_rate, strain_psd, seed=opt.fake_strain_seed) strain._epoch = lal.LIGOTimeGPS(opt.gps_start_time) if opt.injection_file: logging.info("Applying injections") injections = InjectionSet(opt.injection_file) injections.apply(strain, opt.channel_name[0:2], distance_scale=opt.injection_scale_factor) if opt.sgburst_injection_file: logging.info("Applying sine-Gaussian burst injections") injections = SGBurstInjectionSet(opt.sgburst_injection_file) injections.apply(strain, opt.channel_name[0:2], distance_scale=opt.injection_scale_factor) if precision == 'single': logging.info("Converting to float32") strain = (dyn_range_fac * strain).astype(pycbc.types.float32) if opt.injection_file or opt.sgburst_injection_file: strain.injections = injections if opt.taper_data: logging.info("Tapering data") # Use auto-gating stuff for this, a one-sided gate is a taper pd_taper_window = opt.taper_data gate_params = [(strain.start_time, 0., pd_taper_window)] gate_params.append( (strain.end_time, 0., pd_taper_window) ) gate_data(strain, gate_params) strain.gating_info = gating_info return strain
w_lal = lal.CreateHannREAL4Window(seg_len) print "hann props pycbc", w_pycbc.sum(), w_pycbc.squared_norm().sum() print "hann props lal", w_lal.sum, w_lal.sumofsquares # Check that the median bias is the same print "%s segments" % nsegs print "BIAS pycbc", pycbc.psd.median_bias(nsegs) print "BIAS lal", lal.RngMedBias(nsegs) # Check the psd norm print "PYCBC psd norm", 2.0 / float(sample_rate) / ( w_pycbc.squared_norm().sum()) / pycbc.psd.median_bias(nsegs) # Same strain preparation for lal and pycbc psd estimation strain = read_frame("LER2.lcf", "H1:LDAS-STRAIN", start_time=start_time - pad_data, duration=duration + pad_data * 2) strain = highpass(strain, frequency=30) strain *= pycbc.DYN_RANGE_FAC strain = TimeSeries(strain, delta_t=strain.delta_t, epoch=strain.start_time, dtype=float32) strain = resample_to_delta_t(strain, 1.0 / sample_rate) strain = strain[int(pad_data * 1.0 / strain.delta_t):len(strain) - int(1.0 / strain.delta_t * pad_data)] psd_pycbc = pycbc.psd.welch(strain, seg_len=seg_len, seg_stride=stride) psd_lal = lal_psd_estimate(seg_len, strain) print psd_pycbc[-1]
from pycbc.frame import read_frame from pycbc.filter import highpass_fir, lowpass_fir from pycbc.psd import welch, interpolate from pycbc.types import TimeSeries try: from urllib.request import urlretrieve except ImportError: # python < 3 from urllib import urlretrieve # Read data and remove low frequency content fname = 'H-H1_LOSC_4_V2-1126259446-32.gwf' url = "https://www.gw-openscience.org/GW150914data/" + fname urlretrieve(url, filename=fname) h1 = highpass_fir(read_frame(fname, 'H1:LOSC-STRAIN'), 15.0, 8) # Calculate the noise spectrum and whiten psd = interpolate(welch(h1), 1.0 / 32) white_strain = (h1.to_frequencyseries() / psd ** 0.5 * psd.delta_f).to_timeseries() # remove some of the high and low frequencies smooth = highpass_fir(white_strain, 25, 8) smooth = lowpass_fir(white_strain, 250, 8) #strech out and shift the frequency upwards to aid human hearing fdata = smooth.to_frequencyseries() fdata.roll(int(1200 / fdata.delta_f)) smooth = TimeSeries(fdata.to_timeseries(), delta_t=1.0/1024) #Take slice around signal smooth = smooth[len(smooth)/2 - 1500:len(smooth)/2 + 3000] smooth.save_to_wav('gw150914_h1_chirp.wav')
# Check that we are using the same hann window w_pycbc = Array(numpy.hanning(seg_len).astype(float32)) w_lal = lal.CreateHannREAL4Window(seg_len) print "hann props pycbc", w_pycbc.sum(), w_pycbc.squared_norm().sum() print "hann props lal", w_lal.sum, w_lal.sumofsquares # Check that the median bias is the same print "%s segments" % nsegs print "BIAS pycbc", pycbc.psd.median_bias(nsegs) print "BIAS lal", lal.RngMedBias(nsegs) # Check the psd norm print "PYCBC psd norm", 2.0 / float(sample_rate) / (w_pycbc.squared_norm().sum()) / pycbc.psd.median_bias(nsegs) # Same strain preparation for lal and pycbc psd estimation strain = read_frame("LER2.lcf", "H1:LDAS-STRAIN", start_time=start_time-pad_data, duration=duration+pad_data*2) strain = highpass(strain, frequency=30) strain *= pycbc.DYN_RANGE_FAC strain = TimeSeries(strain, delta_t=strain.delta_t, epoch=strain.start_time, dtype=float32) strain = resample_to_delta_t(strain, 1.0/sample_rate) strain = strain[int(pad_data*1.0/strain.delta_t):len(strain)-int(1.0/strain.delta_t*pad_data)] psd_pycbc = pycbc.psd.welch(strain, seg_len=seg_len, seg_stride=stride) psd_lal = lal_psd_estimate(seg_len, strain) print psd_pycbc[-1] print psd_lal[-1] pylab.figure(1) pylab.loglog(psd_pycbc.sample_frequencies.numpy(), psd_pycbc.numpy(), label="PyCBC") pylab.loglog(psd_lal.sample_frequencies.numpy(), psd_lal.numpy(), label="LAL")