def connect(host=None, port=None): """Open a new datafind connection Parameters ---------- host : `str` name of datafind server to query port : `int` port of datafind server on host Returns ------- connection : :class:`~glue.datafind.GWDataFindHTTPConnection` the new open connection """ from glue import datafind port = port and int(port) if port is not None and port != 80: cert, key = datafind.find_credential() return datafind.GWDataFindHTTPSConnection(host=host, port=port, cert_file=cert, key_file=key) return datafind.GWDataFindHTTPConnection(host=host, port=port)
def main(centerTime,duration,frameTypes,channelNames,detectors,rightascension,declination,FFTlength,sampleFrequency): #----- Start and stop time for this event. startTime = centerTime - duration / 2; stopTime = centerTime + duration / 2; # zip frameTypes and detectors, and channel names and detectors frameType = dict(zip(detectors,frameTypes)) channelName = dict(zip(detectors,channelNames)) data = dict() white_data = dict() # Read in the data for iDet in detectors: connection = datafind.GWDataFindHTTPConnection() cache = connection.find_frame_urls(iDet.strip('1'), frameType[iDet], startTime, stopTime, urltype='file') data[iDet] = TimeSeries.read(cache,channelName[iDet], format='gwf',start=startTime,end=stopTime) for (iDet,iSeries) in data.iteritems(): # resample data if iSeries.sample_rate.decompose().value != sampleFrequency: iSeries = iSeries.resample(sampleFrequency) asd = iSeries.asd(FFTlength, FFTlength/2., method='median-mean') # Apply ASD to the data to whiten it whitened = iSeries.whiten(FFTlength, FFTlength/2., asd=asd) white_data[iDet] = whitened.fft()
def _query(): if cert is not None: dfconn = datafind.GWDataFindHTTPSConnection( host=host, port=port, cert_file=cert, key_file=key) else: dfconn = datafind.GWDataFindHTTPConnection(host=host, port=port) return dfconn.find_frame_urls(ifo[0].upper(), frametype, gpsstart, gpsend, urltype=urltype, on_gaps=gaps)
def generate_fast_vco(ifo, segment, frames=False, fit=True): """ Parameters: ----------- ifo : start interferometer, e.g. 'L1' segment : array like time segment. first entry start second entry end frames : bool read from frames or nds2 fit : bool fit from imc-f (default) or spline interpolation Returns: -------- vco_data : saves file 'L1:IMC-VCO_PREDICTION-st-dur.hdf' """ st = segment[0] et = segment[1] chan1_pat = '%s:SYS-TIMING_C_FO_A_PORT_11_SLAVE_CFC_FREQUENCY_5' chan2_pat = '%s:IMC-F_OUT_DQ' if frames: connection = datafind.GWDataFindHTTPConnection() cache = connection.find_frame_urls( ifo[0], '%s_R' % ifo, st, et + 1, urltype='file') if fit: imc = TimeSeries.read(cache, chan2_pat % ifo, st, et) else: imc = TimeSeries.read(cache, chan2_pat % ifo, st, st + 1) pslvco = TimeSeries.read(cache, chan1_pat % ifo, st, et + 1) else: if fit: imc = TimeSeries.fetch(chan2_pat % ifo, st, et) else: imc = TimeSeries.fetch(chan2_pat % ifo, st, st + 1) pslvco = TimeSeries.fetch(chan1_pat % ifo, st, et + 1) pslvco = pslvco[16 + 8::16] if fit: imc_srate = int(imc.sample_rate.value) imc2 = imc[imc_srate / 2::imc_srate] data = np.array((imc2.value, pslvco.value)).T vco_interp = fit_with_imc(data, imc) else: vco_interp = interp_spline(pslvco) chan = "%s:IMC-VCO_PREDICTION" % (ifo,) vco_data = TimeSeries(vco_interp, epoch=st, sample_rate=256, name=chan, channel=chan) return vco_data
def find_frames(site, frametype, gpsstart, gpsend, **kwargs): """Find frames for given site and frametype """ # connect host = kwargs.pop('host', None) port = kwargs.pop('port', None) port = port and int(port) if port is not None and port != 80: cert, key = datafind.find_credential() connection = datafind.GWDataFindHTTPSConnection( host=host, port=port, cert_file=cert, key_file=key) else: connection = datafind.GWDataFindHTTPConnection(host=host, port=port) # find frames kwargs.setdefault('urltype', 'file') return connection.find_frame_urls(site[0], frametype, gpsstart, gpsend, **kwargs)
def find_types(site=None, match=None): """Query the DataFind server for frame types matching the given options """ conn = datafind.GWDataFindHTTPConnection() return conn.find_types(site=site, match=match)
snrs.append(float(line.split('\t')[1])) freqs.append(float(line.split('\t')[2])) # for now let's just assume you're not looking at a lock # longer than a day... for i in range(int(86400 / t)): new_times = [] new_freqs = [] for time, snr, freq in zip(times, snrs, freqs): if time > st and time < st + t: new_times.append(time) new_freqs.append(freq) if len(new_times) == 0: st += t continue connection = datafind.GWDataFindHTTPConnection() cache = connection.find_frame_urls( 'L', 'L1_C', st, st + t, urltype='file') data = TimeSeries.read(cache, channel, st, st + t) data2 = detrend(data) data = TimeSeries( data2, dx=data.dx, sample_rate=data.sample_rate, x0=data.x0) specgram = data.spectrogram2(fftlength=.1, overlap=0.1 * 0.9) specgram = specgram.ratio('median') plot = specgram.plot(vmin=1, vmax=10, norm='log') plot.add_colorbar(label='amplitude relative to median') ax = plot.gca() ax.set_ylim(40, 7e4) ax.set_yscale('log') # ax.scatter(new_times,new_freqs,'x',color='r') for time, freq in zip(new_times, new_freqs):
def dump_calibrated_data(fname): data = numpy.load(fname) # Figure out the times covered by the file from the filename # I should start using HDF5 so I can store metadata temp = fname.split('.')[0] temp = temp.split('-') ifo = temp[0] st, dur = int(temp[-2]), int(temp[-1]) et = st + dur maxidx = len(data) width = 45 weights = 1. - ((numpy.arange(-width, width) / float(width))**2) # The VCO frequencies are integers so we could dither them # to avoid quantization error if we wanted to be fancy # but it seems to make no differece if False: from numpy.random import triangular data[:, 1] += triangular(-1., 0., 1., size=len(data)) # Just fit the whole thing at once, to get a single coefficient a, b = numpy.polyfit(data[:, 0], data[:, 1], 1) print "%.1f %u" % (a, b) # Slide through the data fitting PSL to IMC for data around each sample coeffs = [] for idx in xrange(maxidx): idx1 = max(0, idx - width) idx2 = min(idx + width, maxidx) coeffs.append( numpy.polyfit(data[idx1:idx2, 0], data[idx1:idx2, 1], 1, w=weights[idx1 - idx + width:idx2 - idx + width])) coeffs = numpy.array(coeffs) times = numpy.arange(len(coeffs)) + 0.5 connection = datafind.GWDataFindHTTPConnection() cache = connection.find_frame_urls(ifo[0], '%s_R' % ifo, st, et, urltype='file') imc = TimeSeries.read(cache, "%s:IMC-F_OUT_DQ" % ifo, st, et) imc = imc[::16384 / 256] print imc samp_times = numpy.arange(len(imc)) / 256. coeffs0 = numpy.interp(samp_times, times, coeffs[:, 0]) coeffs1 = numpy.interp(samp_times, times, coeffs[:, 1]) - 7.6e7 vco_interp = coeffs0 * imc.data + coeffs1 chan = "%s:IMC-VCO_PREDICTION" % (ifo, ) vco_data = TimeSeries(vco_interp, epoch=st, sample_rate=imc.sample_rate.value, name=chan, channel=chan) vco_data.write("%s-vcoprediction-%u-%u.hdf" % (ifo, st, dur), format='hdf')
def main(): # Parse commandline arguments opts = parse_commandline() ########################################################################### # Parse Ini File # ########################################################################### # ---- Create configuration-file-parser object and read parameters file. cp = ConfigParser.ConfigParser() cp.read(opts.inifile) # ---- Read needed variables from [parameters] and [channels] sections. alwaysPlotFlag = cp.getint('parameters', 'alwaysPlotFlag') sampleFrequency = cp.getint('parameters', 'sampleFrequency') blockTime = cp.getint('parameters', 'blockTime') searchFrequencyRange = json.loads( cp.get('parameters', 'searchFrequencyRange')) searchQRange = json.loads(cp.get('parameters', 'searchQRange')) searchMaximumEnergyLoss = cp.getfloat('parameters', 'searchMaximumEnergyLoss') searchWindowDuration = cp.getfloat('parameters', 'searchWindowDuration') whiteNoiseFalseRate = cp.getfloat('parameters', 'whiteNoiseFalseRate') plotTimeRanges = json.loads(cp.get('parameters', 'plotTimeRanges')) plotFrequencyRange = json.loads(cp.get('parameters', 'plotFrequencyRange')) plotNormalizedERange = json.loads( cp.get('parameters', 'plotNormalizedERange')) frameCacheFile = cp.get('channels', 'frameCacheFile') frameTypes = cp.get('channels', 'frameType').split(',') channelNames = cp.get('channels', 'channelName').split(',') detectorName = channelNames[0].split(':')[0] det = detectorName.split('1')[0] ########################################################################### # create output directory # ########################################################################### # if outputDirectory not specified, make one based on center time if opts.outDir is None: outDir = './scans' else: outDir = opts.outDir + '/' outDir += '/' # report status if not os.path.isdir(outDir): if opts.verbose: print('creating event directory') os.makedirs(outDir) if opts.verbose: print('outputDirectory: {0}'.format(outDir)) ######################################################################## # Determine if this is a normal omega scan or a Gravityspy # # omega scan with unique ID. If Gravity spy then additional # # files and what not must be generated # ######################################################################## IDstring = "{0:.2f}".format(opts.eventTime) ########################################################################### # Process Channel Data # ########################################################################### # find closest sample time to event time centerTime = np.floor(opts.eventTime) + np.round( (opts.eventTime - np.floor(opts.eventTime)) * sampleFrequency) / sampleFrequency # determine segment start and stop times startTime = round(centerTime - blockTime / 2) stopTime = startTime + blockTime # This is for ordering the output page by SNR loudestEnergyAll = [] channelNameAll = [] peakFreqAll = [] mostSignQAll = [] for channelName in channelNames: if 'STRAIN' in channelName: frameType = frameTypes[0] else: frameType = frameTypes[1] # Read in the data if opts.NSDF: data = TimeSeries.fetch(channelName, startTime, stopTime) else: connection = datafind.GWDataFindHTTPConnection() cache = connection.find_frame_urls(det, frameType, startTime, stopTime, urltype='file') data = TimeSeries.read(cache, channelName, format='gwf', start=startTime, end=stopTime) # resample data if data.sample_rate.decompose().value != sampleFrequency: data = data.resample(sampleFrequency) # Cropping the results before interpolation to save on time and memory # perform the q-transform try: specsgrams = [] for iTimeWindow in plotTimeRanges: durForPlot = iTimeWindow / 2 try: outseg = Segment(centerTime - durForPlot, centerTime + durForPlot) qScan = data.q_transform(qrange=(4, 64), frange=(10, 2048), gps=centerTime, search=0.5, tres=0.002, fres=0.5, outseg=outseg, whiten=True) qValue = qScan.q qScan = qScan.crop(centerTime - iTimeWindow / 2, centerTime + iTimeWindow / 2) except: outseg = Segment(centerTime - 2 * durForPlot, centerTime + 2 * durForPlot) qScan = data.q_transform(qrange=(4, 64), frange=(10, 2048), gps=centerTime, search=0.5, tres=0.002, fres=0.5, outseg=outseg, whiten=True) qValue = qScan.q qScan = qScan.crop(centerTime - iTimeWindow / 2, centerTime + iTimeWindow / 2) specsgrams.append(qScan) loudestEnergyAll.append(qScan.max().value) peakFreqAll.append(qScan.yindex[np.where( qScan.value == qScan.max().value)[1]].value[0]) mostSignQAll.append(qValue) channelNameAll.append(channelName) except: print('bad channel {0}: skipping qScan'.format(channelName)) continue if opts.make_webpage: # Set some plotting params myfontsize = 15 mylabelfontsize = 20 myColor = 'k' if detectorName == 'H1': title = "Hanford" elif detectorName == 'L1': title = "Livingston" else: title = "VIRGO" if 1161907217 < startTime < 1164499217: title = title + ' - ER10' elif startTime > 1164499217: title = title + ' - O2a' elif 1126400000 < startTime < 1137250000: title = title + ' - O1' else: raise ValueError("Time outside science or engineering run\ or more likely code not updated to reflect\ new science run") # Create one image containing all spectogram grams superFig = Plot(figsize=(27, 6)) superFig.add_subplot(141, projection='timeseries') superFig.add_subplot(142, projection='timeseries') superFig.add_subplot(143, projection='timeseries') superFig.add_subplot(144, projection='timeseries') iN = 0 for iAx, spec in zip(superFig.axes, specsgrams): iAx.plot(spec) iAx.set_yscale('log', basey=2) iAx.set_xscale('linear') xticks = np.linspace(spec.xindex.min().value, spec.xindex.max().value, 5) xticklabels = [] dur = float(plotTimeRanges[iN]) [ xticklabels.append(str(i)) for i in np.linspace(-dur / 2, dur / 2, 5) ] iAx.set_xticks(xticks) iAx.set_xticklabels(xticklabels) iAx.set_xlabel('Time (s)', labelpad=0.1, fontsize=mylabelfontsize, color=myColor) iAx.set_ylim(10, 2048) iAx.yaxis.set_major_formatter(ScalarFormatter()) iAx.ticklabel_format(axis='y', style='plain') iN = iN + 1 superFig.add_colorbar(ax=iAx, cmap='viridis', label='Normalized energy', clim=plotNormalizedERange, pad="3%", width="5%") superFig.suptitle(title, fontsize=mylabelfontsize, color=myColor, x=0.51) superFig.save(outDir + channelName.replace(':', '-') + '_' + IDstring + '_spectrogram_' + '.png') if opts.make_webpage: channelNameAll = [i.replace(':', '-') for i in channelNameAll] loudestEnergyAll = [str(i) for i in loudestEnergyAll] peakFreqAll = [str(i) for i in peakFreqAll] mostSignQAll = [str(i) for i in mostSignQAll] # Zip SNR with channelName loudestEnergyAll = dict(zip(channelNameAll, loudestEnergyAll)) peakFreqAll = dict(zip(channelNameAll, peakFreqAll)) mostSignQAll = dict(zip(channelNameAll, mostSignQAll)) plots = glob.glob(outDir + '*.png'.format(channelName)) plots = [i.split('/')[-1] for i in plots] channelPlots = dict(zip(channelNameAll, plots)) f1 = open(outDir + 'index.html', 'w') env = Environment(loader=FileSystemLoader('../')) template = env.get_template('webpage/omegatemplate.html') print >> f1, template.render(channelNames=channelNameAll, SNR=loudestEnergyAll, Q=mostSignQAll, FREQ=peakFreqAll, ID=IDstring, plots=channelPlots) f1.close() for channelName in channelNameAll: f2 = open(outDir + '%s.html' % channelName, 'w') template = env.get_template('webpage/channeltemplate.html'.format( opts.pathToHTML)) # List plots for given channel print >> f2, template.render(channelNames=channelNameAll, thisChannel=channelName, plots=channelPlots) f2.close()