def get_LVAdata_from_file(filename, as_dict=False): """ this function takes the name of an xml file containing a single LVAlertTable and it returns: host: the machine the payload file was created on full_path: the full path to (and including) the payload file general_dir: the directory in gracedb that the output of your code should be written to uid: the gracedb unique id associated with the event in the LVAlertTable """ doc = utils.load_filename(filename) lvatable = table.get_table(doc, LVAlertTable.tableName) file = lvatable[0].file uid = lvatable[0].uid data_loc = lvatable[0].temp_data_loc if as_dict: return { "file" : lvatable[0].file, "uid" : lvatable[0].uid, "data_loc" : lvatable[0].temp_data_loc, "description" : lvatable[0].description, "alert_type" : lvatable[0].alert_type, } return file, uid, data_loc
def from_filenames(cls, filenames, name, verbose=False): """ Convenience function to deserialize CoincParamsDistributions objects from a collection of XML files and return their sum. The return value is a two-element tuple. The first element is the deserialized and summed CoincParamsDistributions object, the second is a segmentlistdict indicating the interval of time spanned by the out segments in the search_summary rows matching the process IDs that were attached to the CoincParamsDistributions objects in the XML. """ self = None for n, filename in enumerate(filenames, 1): if verbose: print >> sys.stderr, "%d/%d:" % (n, len(filenames)), xmldoc = ligolw_utils.load_filename( filename, verbose=verbose, contenthandler=cls.contenthandler) if self is None: self = cls.from_xml(xmldoc, name) seglists = lsctables.SearchSummaryTable.get_table( xmldoc).get_out_segmentlistdict(set([self.process_id ])).coalesce() else: other = cls.from_xml(xmldoc, name) self += other seglists |= lsctables.SearchSummaryTable.get_table( xmldoc).get_out_segmentlistdict(set([other.process_id ])).coalesce() del other xmldoc.unlink() return self, seglists
def parse_psd_file(filestr, fvals): """ Map the user-provided PSD file string into a function to be called as PSD(f). """ if not os.path.isfile(filestr): try: psd_func = getattr(lalsimulation, filestr) return numpy.array(map(psd_func, fvals)) except AttributeError: pass try: xmldoc = utils.load_filename(filestr, contenthandler=PSDContentHandler) psd = read_psd_xmldoc(xmldoc).values()[0] f = numpy.arange(0, len(psd.data) * psd.deltaF, psd.deltaF) psd = psd.data except: # FIXME: ugh! try: f, psd = numpy.loadtxt(filestr, unpack=True) except: exit("Can't parse PSD specifier %s as function or file." % filestr) def anon_interp(newf): return numpy.interp(newf, f, psd) return numpy.array(map(anon_interp, fvals))
def reference_psds_for_filename(filename): xmldoc = ligolw_utils.load_filename( filename, contenthandler=lal.series.PSDContentHandler) psds = lal.series.read_psd_xmldoc(xmldoc) return dict( (key, timing.InterpolatedPSD(filter.abscissa(psd), psd.data.data)) for key, psd in psds.iteritems() if psd is not None)
def ReadSnglInspiralFromFiles(fileList, verbose=False): """ Read the SnglInspiralTables from a list of files @param fileList: list of input files @param verbose: print progress """ # NOTE: this function no longer carries out event ID mangling (AKA # reassignment). Please adjust calling codes accordingly! # This means that identical event IDs produced by lalapps_thinca in # non-slide files having the same GPS start time will stay identical, # affecting zerolag and injection runs made over the same data. # # In consequence, if the calling code is going to reconstruct coincs # from the sngl event IDs, and if these include multiple injection # runs, coinc finding should be done one file at a time - see the # readCoincInspiralFromFiles function in CoincInspiralUtils.py sngls = lsctables.New(lsctables.SnglInspiralTable, \ columns=lsctables.SnglInspiralTable.loadcolumns) for i,file in enumerate(fileList): if verbose: print str(i+1)+"/"+str(len(fileList))+": " xmldoc = utils.load_filename(file, verbose=verbose) try: sngl_table = table.get_table(xmldoc, lsctables.SnglInspiralTable.tableName) except ValueError: #some xml files have no sngl table, that's OK sngl_table = None if sngl_table: sngls.extend(sngl_table) xmldoc.unlink() #free memory return sngls
def coinc_without_inj(coinc, tmpdir): """Produce a coinc.xml file with the found coincs stripped out.""" filename = str(tmpdir / 'coinc_without_inj.xml') xmldoc = ligolw_utils.load_filename(coinc, contenthandler=ContentHandler) # Prune coinc_def table coinc_def_table = lsctables.CoincDefTable.get_table(xmldoc) included = [row for row in coinc_def_table if row.search_coinc_type == InspiralCoincDef.search_coinc_type and row.search == InspiralCoincDef.search] included_coinc_def_ids = {row.coinc_def_id for row in included} coinc_def_table[:] = included # Prune coinc table coinc_table = lsctables.CoincTable.get_table(xmldoc) included = [row for row in coinc_table if row.coinc_def_id in included_coinc_def_ids] included_coinc_ids = {row.coinc_event_id for row in included} coinc_table[:] = included # Prune coinc_map table coinc_map_table = lsctables.CoincMapTable.get_table(xmldoc) coinc_map_table[:] = [row for row in coinc_map_table if row.coinc_event_id in included_coinc_ids] ligolw_utils.write_filename(xmldoc, filename) return filename
def get_loud_trigs(fList, veto_file, new_snr_cut): """ Return a list(s) of single inspiral triggers that are above the new snr threshold for every combination of file in the file list and application of veto in the veto file list. """ trigs = lsctables.New(lsctables.SnglInspiralTable) searched_segs = segments.segmentlist() for fname in fList: xmldoc = utils.load_filename(fname, gz=True, contenthandler=DefaultContentHandler) tbl = lsctables.table.get_table(xmldoc, lsctables.SnglInspiralTable.tableName) trigs.extend( [tbl[i] for i in (tbl.get_new_snr() > new_snr_cut).nonzero()[0]]) search_summary = lsctables.table.get_table( xmldoc, lsctables.SearchSummaryTable.tableName) searched_segs += search_summary.get_outlist() if isinstance(veto_file, list): # If we have multiple veto files, return results for applying each one lt = [] tg = [] for vf in veto_file: veto_segs = get_segments_from_xml(vf) segs_after_veto = searched_segs - veto_segs print vf, 'livetime', abs(segs_after_veto) tg.append(trigs.veto(veto_segs)) lt.append(abs(segs_after_veto)) return tg, lt else: veto_segs = get_segments_from_xml(veto_file) segs_after_veto = searched_segs - veto_segs print veto_file, 'livetime', abs(segs_after_veto) return trigs.veto(veto_segs), abs(segs_after_veto)
def check_segment_availability(grb_name, grb_time, query_start, query_end, offset, ifo, segmentName): ''' Searches +/- offset from GRB time to download the latest segment lists then extracts times and puts them into a txt file. ''' args = {'grb_name' : grb_name, 'query_start' : query_start, 'query_end' : query_end, 'ifo' : ifo, 'segmentName' : segmentName} cmd = "ligolw_segment_query --database --query-segments --include-segments '{segmentName}' --gps-start-time {query_start} --gps-end-time {query_end} > ./segments{ifo}_grb{grb_name}.xml".format(**args) print '>>',cmd print process = subprocess.Popen([cmd], shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) output,err = process.communicate() # try to open the file try: doc = utils.load_filename("segments{ifo}_grb{grb_name}.xml".format(**args), contenthandler = lsctables.use_in(ligolw.LIGOLWContentHandler)) except: raise IOError, "Error reading file: segments{ifo}_grb{grb_name}.xml".format(**args) # extract the segment list from segment:table and store in a txt file segs = table.get_table(doc, "segment") seglist = segments.segmentlist(segments.segment(s.start_time, s.end_time) for s in segs) segmentsUtils.tosegwizard(file("{ifo}-science_grb{grb_name}.txt".format(**args),'w'),seglist,header = True) print ">> %s segments +/-%ds from %ds found:"%(ifo,offset,grb_time) for s in segs: print "Start:",s.start_time,"End:",s.end_time,"Duration:",s.end_time-s.start_time print return
def retrieve_event_from_coinc(fname_coinc): from glue.ligolw import lsctables, table, utils from RIFT import lalsimutils event_dict = {} samples = table.get_table( utils.load_filename(fname_coinc, contenthandler=lalsimutils.cthdler), lsctables.SnglInspiralTable.tableName) event_duration = 4 # default ifo_list = [] for row in samples: m1 = row.mass1 m2 = row.mass2 ifo_list.append(row.ifo) try: event_duration = row.event_duration # may not exist except: print(" event_duration field not in XML ") event_dict["m1"] = row.mass1 event_dict["m2"] = row.mass2 event_dict["s1z"] = row.spin1z event_dict["s2z"] = row.spin2z event_dict["tref"] = row.end_time + 1e-9 * row.end_time_ns event_dict["IFOs"] = list(set(ifo_list)) event_dict["SNR"] = row.snr return event_dict
def from_filenames(cls, filenames, name, verbose = False): """ Convenience function to deserialize CoincParamsDistributions objects from a collection of XML files and return their sum. The return value is a two-element tuple. The first element is the deserialized and summed CoincParamsDistributions object, the second is a segmentlistdict indicating the interval of time spanned by the out segments in the search_summary rows matching the process IDs that were attached to the CoincParamsDistributions objects in the XML. """ self = None for n, filename in enumerate(filenames, 1): if verbose: print >>sys.stderr, "%d/%d:" % (n, len(filenames)), xmldoc = ligolw_utils.load_filename(filename, verbose = verbose, contenthandler = cls.contenthandler) if self is None: self = cls.from_xml(xmldoc, name) seglists = lsctables.SearchSummaryTable.get_table(xmldoc).get_out_segmentlistdict(set([self.process_id])).coalesce() else: other = cls.from_xml(xmldoc, name) self += other seglists |= lsctables.SearchSummaryTable.get_table(xmldoc).get_out_segmentlistdict(set([other.process_id])).coalesce() del other xmldoc.unlink() return self, seglists
def do_start(self): """GstBaseSrc->start virtual method""" xml_location = self.get_property("xml-location") if xml_location is None: self.error( "xml-location property is unset, cannot load template bank") return False self.__templates = list( lsctables.SnglInspiralTable.get_table( utils.load_filename(xml_location))) start_time = self.get_property("start-time") duration = self.get_property("duration") end_time = start_time + duration min_waiting_time = self.get_property("min-waiting-time") max_waiting_time = self.get_property("max-waiting-time") self.__last_time = start_time self.__stream_end_time = end_time self.__triggertimes = [ self.make_trigger_times(start_time, end_time, min_waiting_time, max_waiting_time) for i in range(len(self.__templates)) ] self.__ntriggers = 0 #self.src_pads().next().push_event(gst.event_new_new_segment(False, 1.0, gst.FORMAT_TIME, start_time, end_time, start_time)) return True
def ReadSimInspiralFromFiles(fileList, verbose=False): """ Read the simInspiral tables from a list of files @param fileList: list of input files @param verbose: print ligolw_add progress """ simInspiralTriggers = None lsctables.use_in(ExtractSimInspiralTableLIGOLWContentHandler) for thisFile in fileList: doc = utils.load_filename( thisFile, gz=(thisFile or "stdin").endswith(".gz"), verbose=verbose, contenthandler=ExtractSimInspiralTableLIGOLWContentHandler) # extract the sim inspiral table try: simInspiralTable = lsctables.SimInspiralTable.get_table(doc) except: simInspiralTable = None if simInspiralTriggers and simInspiralTable: simInspiralTriggers.extend(simInspiralTable) elif not simInspiralTriggers: simInspiralTriggers = simInspiralTable return simInspiralTriggers
def open_xmldoc(fobj, **kwargs): """Try and open an existing LIGO_LW-format file, or create a new Document Parameters ---------- fobj : `str`, `file` file path or open file object to read **kwargs other keyword arguments to pass to :func:`~glue.ligolw.utils.load_filename`, or :func:`~glue.ligolw.utils.load_fileobj` as appropriate Returns -------- xmldoc : :class:`~glue.ligolw.ligolw.Document` either the `Document` as parsed from an existing file, or a new, empty `Document` """ from glue.ligolw.lsctables import use_in from glue.ligolw.ligolw import (Document, LIGOLWContentHandler) from glue.ligolw.utils import load_filename, load_fileobj try: # try and load existing file if isinstance(fobj, string_types): kwargs.setdefault('contenthandler', use_in(LIGOLWContentHandler)) return load_filename(fobj, **kwargs) if isinstance(fobj, FILE_LIKE): kwargs.setdefault('contenthandler', use_in(LIGOLWContentHandler)) return load_fileobj(fobj, **kwargs)[0] except (OSError, IOError): # or just create a new Document return Document()
def getAuxChannels(self, inputList): intermediateTable = { "type": [], "ifo": [], "qscan_time": [], "qscan_dir": [], "channel_name": [], "peak_time": [], "peak_frequency": [], "peak_q": [], "peak_significance": [], "peak_amplitude": [], } try: doc = utils.load_filename( inputList[0] + "/summary.xml", verbose=True, gz=False, xmldoc=None, contenthandler=None ) qscanTable = table.get_table(doc, "qscan:summary:table") except: print >> sys.stderr, "failed to read" + inputList[0] + "/summary.xml" return intermediateTable for channel in qscanTable: for param in self.paramMaps: intermediateTable[param[0]].append(eval("channel." + param[1])) intermediateTable["qscan_dir"].append(inputList[0]) # if len(inputList) == 4: intermediateTable["qscan_time"].append(inputList[1]) intermediateTable["type"].append(inputList[2]) intermediateTable["ifo"].append(inputList[3]) return intermediateTable
def parse_psd_file(filestr, fvals): """ Map the user-provided PSD file string into a function to be called as PSD(f). """ if not os.path.isfile(filestr): try: psd_func = getattr(lalsimulation, filestr) return numpy.array(map(psd_func, fvals)) except AttributeError: pass try: xmldoc = utils.load_filename(filestr, contenthandler=PSDContentHandler) psd = read_psd_xmldoc(xmldoc).values()[0] f = numpy.arange(0, len(psd.data)*psd.deltaF, psd.deltaF) psd = psd.data except: # FIXME: ugh! try: f, psd = numpy.loadtxt(filestr, unpack=True) except: exit("Can't parse PSD specifier %s as function or file." % filestr) def anon_interp(newf): return numpy.interp(newf, f, psd) return numpy.array(map(anon_interp, fvals))
def parse(self, stop_on=[]): from glue.ligolw import table from glue.ligolw import lsctables from glue.ligolw import utils xml_doc = utils.load_filename(self.path, gz=False) print xml_doc
def loadSingleBurst( files, trigs_dict=None): """ loads snglburst tables (produced by Omicron) into trgdict object files - is the list of file names """ if type(files) is str: files = [files] if trigs_dict is None: trigs_dict = trigdict() for file in files: for row in table.get_table( ligolw_utils.load_filename(file, contenthandler=lsctables.use_in(ligolw.LIGOLWContentHandler)), lsctables.SnglBurstTable.tableName ): channel = "%s-%s_%s"%(row.ifo, row.channel.replace("-","_"), row.search) tcent = row.peak_time + 1e-9*row.peak_time_ns tstart = row.start_time + 1e-9*row.start_time_ns dur = row.duration fpeak = row.peak_frequency fcent = row.central_freq bndwth = row.bandwidth amp = row.amplitude snr = row.snr conf = row.confidence chi2 = row.chisq chi2_dof = row.chisq_dof trigger = [tstart, dur, tcent, fpeak, fcent, bndwth, amp, snr, conf, chi2, chi2_dof] if channel in trigs_dict.channels(): trigs_dict[channel].append( trigger ) ### SingleBurst trigger structure else: trigs_dict[channel] = [ trigger ] return trigs_dict
def get_loud_trigs(fList, veto_file, new_snr_cut): """ Return a list(s) of single inspiral triggers that are above the new snr threshold for every combination of file in the file list and application of veto in the veto file list. """ trigs = lsctables.New(lsctables.SnglInspiralTable) searched_segs = segments.segmentlist() for fname in fList: xmldoc = utils.load_filename(fname, gz=True, contenthandler=DefaultContentHandler) tbl = lsctables.SnglInspiralTable.get_table(xmldoc) trigs.extend([tbl[i] for i in (tbl.get_new_snr() > new_snr_cut).nonzero()[0]]) search_summary = lsctables.SearchSummaryTable.get_table(xmldoc) searched_segs += search_summary.get_outlist() if isinstance(veto_file, list): # If we have multiple veto files, return results for applying each one lt = [] tg = [] for vf in veto_file: veto_segs = get_segments_from_xml(vf) segs_after_veto = searched_segs - veto_segs print vf, 'livetime', abs(segs_after_veto) tg.append(trigs.veto(veto_segs)) lt.append(abs(segs_after_veto)) return tg, lt else: veto_segs = get_segments_from_xml(veto_file) segs_after_veto = searched_segs - veto_segs print veto_file, 'livetime', abs(segs_after_veto) return trigs.veto(veto_segs), abs(segs_after_veto)
def get_combined_array(tablename, childnode): # FIXME assumes that all the xml files have the same binned array tables # Figure out the shape of the arrays in the file, make an array with one more # dimension, the number of files from sys.argv[1:] xmldoc = utils.load_filename(sys.argv[1], verbose=True, gz = (sys.argv[1] or "stdin").endswith(".gz")) xmldoc = xmldoc.childNodes[0] A = rate.binned_array_from_xml(xmldoc.childNodes[childnode], tablename) bins = rate.bins_from_xml(xmldoc.childNodes[childnode]) out = numpy.zeros((len(sys.argv[1:]),)+A.array.shape,dtype="float") # Read the data for i, f in enumerate(sys.argv[1:]): xmldoc = utils.load_filename(f, verbose=True, gz = (f or "stdin").endswith(".gz")) xmldoc = xmldoc.childNodes[0] out[i] = rate.binned_array_from_xml(xmldoc.childNodes[childnode], tablename).array A.array = numpy.zeros(A.array.shape) return bins, out, A
def query_segments_xml(xml_location, gps_start, gps_end, spec): """ Retrieve the segment table from a location, and clip segments to (gps_start, gps_end). If spec is given, retrieve only segments with this definer, otherwise, get all of them. """ if spec is None: spec = True else: #ifo, definer, version = spec.split(":") definer = spec.split(":") ifo, definer, version = definer[0], ":".join( definer[1:-1]), definer[-1] xmldoc = utils.load_filename(xml_location) segment_definer = table.get_table(xmldoc, lsctables.SegmentDefTable.tableName) # FIXME: ifo in ifos? What does a segment for a set of ifos even mean? seg_def_id = [ sd.segment_def_id for sd in segment_definer if spec and ifo in sd.get_ifos() and definer == sd.name ] if len(seg_def_id) != 1: raise ValueError("Need exactly one definer row for %s:%s:%s, got %d" % (ifo, definer, version, len(seg_def_id))) seg_def_id = seg_def_id[0] segment = table.get_table(xmldoc, lsctables.SegmentTable.tableName) return segmentlist( [s.get() for s in segment if s.segment_def_id == seg_def_id])
def parse_veto_definer(veto_def_filename): """ Parse a veto definer file from the filename and return a dictionary indexed by ifo and veto definer category level. Parameters ---------- veto_def_filename: str The path to the veto definer file Returns: parsed_definition: dict Returns a dictionary first indexed by ifo, then category level, and finally a list of veto definitions. """ from glue.ligolw import table, lsctables, utils as ligolw_utils from glue.ligolw.ligolw import LIGOLWContentHandler as h lsctables.use_in(h) indoc = ligolw_utils.load_filename(veto_def_filename, False, contenthandler=h) veto_table = table.get_table(indoc, 'veto_definer') ifo = veto_table.getColumnByName('ifo') name = veto_table.getColumnByName('name') version = numpy.array(veto_table.getColumnByName('version')) category = numpy.array(veto_table.getColumnByName('category')) start = numpy.array(veto_table.getColumnByName('start_time')) end = numpy.array(veto_table.getColumnByName('end_time')) start_pad = numpy.array(veto_table.getColumnByName('start_pad')) end_pad = numpy.array(veto_table.getColumnByName('end_pad')) data = {} for i in range(len(veto_table)): if ifo[i] not in data: data[ifo[i]] = {} # The veto-definer categories are weird! Hardware injections are stored # in "3" and numbers above that are bumped up by one (although not # often used any more). So we remap 3 to H and anything above 3 to # N-1. 2 and 1 correspond to 2 and 1 (YAY!) if category[i] > 3: curr_cat = "CAT_{}".format(category[i]-1) elif category[i] == 3: curr_cat = "CAT_H" else: curr_cat = "CAT_{}".format(category[i]) if curr_cat not in data[ifo[i]]: data[ifo[i]][curr_cat] = [] veto_info = {'name': name[i], 'version': version[i], 'start': start[i], 'end': end[i], 'start_pad': start_pad[i], 'end_pad': end_pad[i], } data[ifo[i]][curr_cat].append(veto_info) return data
def load_xml_file(filename): """Wrapper to ligolw's utils.load_filename""" xml_doc = utils.load_filename(filename, gz=filename.endswith("gz"), contenthandler=lsctables.use_in( ligolw.LIGOLWContentHandler)) return xml_doc
def __init__(self, filename, approximant=None, **kwds): self.indoc = ligolw_utils.load_filename( filename, False, contenthandler=LIGOLWContentHandler) self.table = table.get_table(self.indoc, lsctables.SnglInspiralTable.tableName) self.extra_args = kwds self.approximant_str = approximant
def reference_psds_for_filename(filename): xmldoc = ligolw_utils.load_filename( filename, contenthandler=lal.series.PSDContentHandler) psds = lal.series.read_psd_xmldoc(xmldoc, root_name=None) return { key: timing.InterpolatedPSD(filter.abscissa(psd), psd.data.data, f_high_truncate=opts.f_high_truncate) for key, psd in psds.items() if psd is not None}
def __init__(self, filename, approximant=None, **kwds): self.indoc = ligolw_utils.load_filename( filename, False, contenthandler=LIGOLWContentHandler) self.table = table.get_table( self.indoc, lsctables.SnglInspiralTable.tableName) self.extra_args = kwds self.approximant_str = approximant
def get_coincs_from_coinctable(self, files): """ read data from coinc tables (xml format) FIXME: currently assumes one coinc per file!!! """ for file in files: coinc = CoincData() xmldoc = utils.load_filename(file) sngltab = tab.get_table(xmldoc, lsctables.SnglInspiralTable.tableName) coinc.set_snr(dict((row.ifo, row.snr) for row in sngltab)) coinc.set_gps( dict((row.ifo, LIGOTimeGPS(row.get_end())) for row in sngltab)) #FIXME: this is put in place to deal with eff_distance = 0 # needs to be fixed upstream in the pipeline effDs = list((row.ifo, row.eff_distance) for row in sngltab) for eD in effDs: if eD[1] == 0.: effDs.append((eD[0], 1.)) effDs.remove(eD) coinc.set_effDs(dict(effDs)) # coinc.set_effDs(dict((row.ifo,row.eff_distance) for row in sngltab)) coinc.set_masses(dict((row.ifo, row.mass1) for row in sngltab), \ dict((row.ifo, row.mass2) for row in sngltab)) ctab = tab.get_table(xmldoc, lsctables.CoincInspiralTable.tableName) #FIXME: ignoring H2 for now, but should be dealt in a better way allifos = list(ctab[0].get_ifos()) try: allifos.remove('H2') except ValueError: pass coinc.set_ifos(allifos) if ctab[0].false_alarm_rate is not None: coinc.set_FAR(ctab[0].false_alarm_rate) try: simtab = tab.get_table(xmldoc, lsctables.SimInspiralTable.tableName) row = siminsptab[0] effDs_inj = {} for ifo in coinc.ifo_list: if ifo == 'H1': effDs_inj[ifo] = row.eff_dist_h elif ifo == 'L1': effDs_inj[ifo] = row.eff_dist_l elif ifo == 'V1': effDs_inj[ifo] = row.eff_dist_v dist_inj = row.distance coinc.set_inj_params(row.latitude,row.longitude,row.mass1,row.mass2, \ dist_inj,effDs_inj) coinc.is_injection = True #FIXME: name the exception! except: pass self.append(coinc)
def readHorizonDistanceFromSummValueTable( fList, verbose=False, contenthandler=SummValueContentHandler): """ read in the SummValueTables from a list of files and return the horizon distance versus total mass @param fList: list of input files @param verbose: boolean (default False) """ output = {} massOutput = {} count = 0 if len(fList) == 0: return output # for each file in the list for thisFile in fList: if verbose: print str(count + 1) + "/" + str(len(fList)) + " " + thisFile count = count + 1 massNum = 0 doc = utils.load_filename(thisFile, contenthandler=contenthandler) try: summ_value_table = table.get_table( doc, lsctables.SummValueTable.tableName) except ValueError: print "ValueError in readHorizonDistanceFromSummValueTable while reading summvalue table from file ", thisFile return output, massOutput # if not summ_value table was filled , then simply returns if summ_value_table is None: return output, massOutput # else for row in summ_value_table: # we should find a name "inspiral_effective_distance" if row.name == 'inspiral_effective_distance': # it may be that the file read is an inspiral file containing only the BNS infomration if (row.comment == '1.40_1.40_8.00') or (row.comment == '1.4_1.4_8'): if not output.has_key(row.ifo): output[row.ifo] = lsctables.New( lsctables.SummValueTable) output[row.ifo].append(row) # or a template bank containing a whole list of inspiral_effective_distance else: if not massOutput.has_key(row.ifo): massOutput[row.ifo] = [ lsctables.New(lsctables.SummValueTable) ] if len(massOutput[row.ifo]) < massNum + 1: massOutput[row.ifo].append( lsctables.New(lsctables.SummValueTable)) massOutput[row.ifo][massNum].append(row) massNum += 1 return output, massOutput
def read_triggers(trigger_file): from glue.ligolw import array, param, ligolw, table, lsctables, utils class ContentHandler(ligolw.LIGOLWContentHandler): pass for module in [array, param, table, lsctables]: module.use_in(ContentHandler) xml_doc = utils.load_filename(trigger_file.path, contenthandler=ContentHandler) return table.get_table(xml_doc, lsctables.SnglBurstTable.tableName)
def load_table(sim_file): xml_doc = utils.load_filename(sim_file, contenthandler=lsctables.use_in( ligolw.LIGOLWContentHandler)) sim_inspiral_table = table.get_table(xml_doc, lsctables.SimInspiralTable.tableName) return sim_inspiral_table
def get_coincs_from_coinctable(self,files): """ read data from coinc tables (xml format) FIXME: currently assumes one coinc per file!!! """ for file in files: coinc = CoincData() xmldoc = utils.load_filename(file, contenthandler=ligolw.LIGOLWContentHandler) sngltab = lsctables.SnglInspiralTable.get_table(xmldoc) coinc.set_snr(dict((row.ifo, row.snr) for row in sngltab)) coinc.set_gps(dict((row.ifo, lal.LIGOTimeGPS(row.get_end())) for row in sngltab)) #FIXME: this is put in place to deal with eff_distance = 0 # needs to be fixed upstream in the pipeline effDs = list((row.ifo,row.eff_distance) for row in sngltab) for eD in effDs: if eD[1] == 0.: effDs.append((eD[0],1.)) effDs.remove(eD) coinc.set_effDs(dict(effDs)) # coinc.set_effDs(dict((row.ifo,row.eff_distance) for row in sngltab)) coinc.set_masses(dict((row.ifo, row.mass1) for row in sngltab), \ dict((row.ifo, row.mass2) for row in sngltab)) ctab = lsctables.CoincInspiralTable.get_table(xmldoc) #FIXME: ignoring H2 for now, but should be dealt in a better way allifos = list(ctab[0].get_ifos()) try: allifos.remove('H2') except ValueError: pass coinc.set_ifos(allifos) if ctab[0].false_alarm_rate is not None: coinc.set_FAR(ctab[0].false_alarm_rate) try: simtab = lsctables.SimInspiralTable.get_table(xmldoc) row = siminsptab[0] effDs_inj = {} for ifo in coinc.ifo_list: if ifo == 'H1': effDs_inj[ifo] = row.eff_dist_h elif ifo == 'L1': effDs_inj[ifo] = row.eff_dist_l elif ifo == 'V1': effDs_inj[ifo] = row.eff_dist_v dist_inj = row.distance coinc.set_inj_params(row.latitude,row.longitude,row.mass1,row.mass2, \ dist_inj,effDs_inj) coinc.is_injection = True #FIXME: name the exception! except: pass self.append(coinc)
def get_segment_summary_times(scienceFile, segmentName): """ This function will find the times for which the segment_summary is set for the flag given by segmentName. Parameters ----------- scienceFile : SegFile The segment file that we want to use to determine this. segmentName : string The DQ flag to search for times in the segment_summary table. Returns --------- summSegList : glue.segments.segmentlist The times that are covered in the segment summary table. """ # Parse the segmentName segmentName = segmentName.split(':') if not len(segmentName) in [2, 3]: raise ValueError("Invalid channel name %s." % (segmentName)) ifo = segmentName[0] channel = segmentName[1] version = '' if len(segmentName) == 3: version = int(segmentName[2]) # Load the filename xmldoc = utils.load_filename( scienceFile.cache_entry.path, gz=scienceFile.cache_entry.path.endswith("gz"), contenthandler=ContentHandler) # Get the segment_def_id for the segmentName segmentDefTable = table.get_table(xmldoc, "segment_definer") for entry in segmentDefTable: if (entry.ifos == ifo) and (entry.name == channel): if len(segmentName) == 2 or (entry.version == version): segDefID = entry.segment_def_id break else: raise ValueError("Cannot find channel %s in segment_definer table."\ %(segmentName)) # Get the segmentlist corresponding to this segmentName in segment_summary segmentSummTable = table.get_table(xmldoc, "segment_summary") summSegList = segments.segmentlist([]) for entry in segmentSummTable: if entry.segment_def_id == segDefID: segment = segments.segment(entry.start_time, entry.end_time) summSegList.append(segment) summSegList.coalesce() return summSegList
def get_combined_array(tablename, childnode): # FIXME assumes that all the xml files have the same binned array tables # Figure out the shape of the arrays in the file, make an array with one more # dimension, the number of files from sys.argv[1:] xmldoc = utils.load_filename(sys.argv[1], verbose=True, gz=(sys.argv[1] or "stdin").endswith(".gz")) xmldoc = xmldoc.childNodes[0] A = rate.binned_array_from_xml(xmldoc.childNodes[childnode], tablename) bins = rate.bins_from_xml(xmldoc.childNodes[childnode]) out = numpy.zeros((len(sys.argv[1:]), ) + A.array.shape, dtype="float") # Read the data for i, f in enumerate(sys.argv[1:]): xmldoc = utils.load_filename(f, verbose=True, gz=(f or "stdin").endswith(".gz")) xmldoc = xmldoc.childNodes[0] out[i] = rate.binned_array_from_xml(xmldoc.childNodes[childnode], tablename).array A.array = numpy.zeros(A.array.shape) return bins, out, A
def get_segment_summary_times(scienceFile, segmentName): """ This function will find the times for which the segment_summary is set for the flag given by segmentName. Parameters ----------- scienceFile : SegFile The segment file that we want to use to determine this. segmentName : string The DQ flag to search for times in the segment_summary table. Returns --------- summSegList : glue.segments.segmentlist The times that are covered in the segment summary table. """ # Parse the segmentName segmentName = segmentName.split(':') if not len(segmentName) in [2,3]: raise ValueError("Invalid channel name %s." %(segmentName)) ifo = segmentName[0] channel = segmentName[1] version = '' if len(segmentName) == 3: version = int(segmentName[2]) # Load the filename xmldoc = utils.load_filename(scienceFile.cache_entry.path, gz=scienceFile.cache_entry.path.endswith("gz"), contenthandler=ContentHandler) # Get the segment_def_id for the segmentName segmentDefTable = table.get_table(xmldoc, "segment_definer") for entry in segmentDefTable: if (entry.ifos == ifo) and (entry.name == channel): if len(segmentName) == 2 or (entry.version==version): segDefID = entry.segment_def_id break else: raise ValueError("Cannot find channel %s in segment_definer table."\ %(segmentName)) # Get the segmentlist corresponding to this segmentName in segment_summary segmentSummTable = table.get_table(xmldoc, "segment_summary") summSegList = segments.segmentlist([]) for entry in segmentSummTable: if entry.segment_def_id == segDefID: segment = segments.segment(entry.start_time, entry.end_time) summSegList.append(segment) summSegList.coalesce() return summSegList
def readHorizonDistanceFromSummValueTable(fList, verbose=False, contenthandler=SummValueContentHandler): """ read in the SummValueTables from a list of files and return the horizon distance versus total mass @param fList: list of input files @param verbose: boolean (default False) """ output = {} massOutput = {} count = 0 if len(fList) == 0: return output # for each file in the list for thisFile in fList: if verbose: print str(count+1)+"/"+str(len(fList))+" " + thisFile count = count+1 massNum = 0 doc = utils.load_filename(thisFile, contenthandler = contenthandler) try: summ_value_table = table.get_table(doc, lsctables.SummValueTable.tableName) except ValueError: print "ValueError in readHorizonDistanceFromSummValueTable while reading summvalue table from file ", thisFile return output,massOutput # if not summ_value table was filled , then simply returns if summ_value_table is None: return output,massOutput # else for row in summ_value_table: # we should find a name "inspiral_effective_distance" if row.name == 'inspiral_effective_distance': # it may be that the file read is an inspiral file containing only the BNS infomration if (row.comment == '1.40_1.40_8.00') or (row.comment == '1.4_1.4_8'): if not output.has_key(row.ifo): output[row.ifo] = lsctables.New(lsctables.SummValueTable) output[row.ifo].append(row) # or a template bank containing a whole list of inspiral_effective_distance else: if not massOutput.has_key(row.ifo): massOutput[row.ifo] = [lsctables.New(lsctables.SummValueTable)] if len(massOutput[row.ifo]) < massNum + 1: massOutput[row.ifo].append(lsctables.New(lsctables.SummValueTable)) massOutput[row.ifo][massNum].append(row) massNum += 1 return output,massOutput
def rapidpe_to_hdf(basegrp, bankfile, samplefiles): # import (or look up template bank) #bank_xmldoc = utils.load_filename(args.tmplt_bank_file, contenthandler=ligolw.LIGOLWContentHandler) bank_xmldoc = utils.load_filename(bankfile, contenthandler=ligolw.LIGOLWContentHandler) try: tmplt_bank = lsctables.SimInspiralTable.get_table(bank_xmldoc) except: tmplt_bank = lsctables.SnglInspiralTable.get_table(bank_xmldoc) for sample_file in samplesfiles: print "Processing %s" % sample_file # Get tables from xmldoc xmldoc = utils.load_filename(sample_file, contenthandler=ligolw.LIGOLWContentHandler) process_params = lsctables.ProcessParamsTable.get_table(xmldoc) samples = lsctables.SimInspiralTable.get_table(xmldoc) run_result = lsctables.SnglInspiralTable.get_table(xmldoc)[0] # Get intrinsic parameter used intr_prms = get_intr_prms_from_pp_table(process_params) # Identify intrinisic ID tmplt_id = obtain_tmplt_id(tmplt_bank, **intr_prms) # Append sample data and metadata subgrp = base_grp.create_group(str(tmplt_id)) xmlutils.append_samples_to_hdf5_group(subgrp, samples) def pp_table_to_dict(pptable): return dict([(pp.param, pp.value) for pp in pptable]) run_info = pp_table_to_dict(process_params) for key in ("snr", "tau0", "ttotal"): run_info[KEY_MAPPING[key]] = getattr(run_result, key) xmlutils.append_metadata_to_hdf5_group(subgrp, run_info) xmldoc.unlink()
def get_refpsd_xml(xml): retdict = dict() xmldoc = ligolw_utils.load_filename(refpsd, contenthandler = PSDContentHandler, verbose = True) root_name = u"psd" xmldoc, = (elem for elem in xmldoc.getElementsByTagName(ligolw.LIGO_LW.tagName) if elem.hasAttribute(u"Name") and elem.Name == root_name) for elem in xmldoc.getElementsByTagName(ligolw.LIGO_LW.tagName): if elem.hasAttribute(u"Name") and elem.Name == u"REAL8FrequencySeries": ifo = ligolw_param.get_pyvalue(elem, u"instrument") # t, = elem.getElementsByTagName(ligolw.Time.tagName) a, = elem.getElementsByTagName(ligolw.Array.tagName) # dims = a.getElementsByTagName(ligolw.Dim.tagName) # f0 = ligolw_param.get_param(elem, u"f0") retdict[str(ifo)] = a.array return retdict
def open_xmldoc(f, **kwargs): """Try and open an existing LIGO_LW-format file, or create a new Document """ from glue.ligolw.lsctables import use_in from glue.ligolw.ligolw import Document from glue.ligolw.utils import load_filename, load_fileobj use_in(kwargs['contenthandler']) try: # try and load existing file if isinstance(f, string_types): return load_filename(f, **kwargs) if isinstance(f, FILE_LIKE): return load_fileobj(f, **kwargs)[0] except (OSError, IOError): # or just create a new Document return Document()
def read_ligolw(filepath, table_name, columns=None): from . import utils # read table into GLUE LIGO_LW if columns: TableType = lsctables.TableByName[table_name] _oldcols = TableType.loadcolumns TableType.loadcolumns = columns if isinstance(filepath, basestring): xmldoc = ligolw_utils.load_filename(filepath) else: xmldoc,_ = ligolw_utils.load_fileobj(filepath) out = ligolw_table.get_table(xmldoc, table_name) if columns: TableType.loadcolumns = _oldcols return utils.to_table(out, columns=columns)
def _read_xml(f, fallbackpath=None): if f is None: doc = filename = None elif isinstance(f, Element): doc = f filename = '' elif isinstance(f, str): try: doc = load_filename(f, contenthandler=ContentHandler) except IOError as e: if e.errno == errno.ENOENT and fallbackpath and \ not os.path.isabs(f): f = os.path.join(fallbackpath, f) doc = load_filename(f, contenthandler=ContentHandler) else: raise filename = f else: doc, _ = load_fileobj(f, contenthandler=ContentHandler) try: filename = f.name except AttributeError: filename = '' return doc, filename
def _read_xml(f): if f is None: doc = filename = None elif isinstance(f, Element): doc = f filename = '' elif isinstance(f, six.string_types): doc = load_filename(f, contenthandler=_ContentHandler) filename = f else: doc, _ = load_fileobj(f, contenthandler=_ContentHandler) try: filename = f.name except AttributeError: filename = '' return doc, filename
def readCoincInspiralFromFiles(fileList, statistic=None): """ read in the Sngl and SimInspiralTables from a list of files if Sngls are found, construct coincs, add injections (if any) also return Sims (if any) @param fileList: list of input files @param statistic: instance of coincStatistic, to use in creating coincs """ if not fileList: return coincInspiralTable(), None if not (isinstance(statistic, coincStatistic)): raise TypeError, "invalid statistic, must be coincStatistic" sims = None coincs = None lsctables.use_in(ExtractCoincInspiralTableLIGOLWContentHandler) for thisFile in fileList: doc = utils.load_filename( thisFile, gz=(thisFile or "stdin").endswith(".gz"), contenthandler=ExtractCoincInspiralTableLIGOLWContentHandler) # extract the sim inspiral table try: simInspiralTable = lsctables.SimInspiralTable.get_table(doc) if sims: sims.extend(simInspiralTable) else: sims = simInspiralTable except: simInspiralTable = None # extract the sngl inspiral table, construct coincs try: snglInspiralTable = lsctables.SnglInspiralTable.get_table(doc) except: snglInspiralTable = None if snglInspiralTable: coincFromFile = coincInspiralTable(snglInspiralTable, statistic) if simInspiralTable: coincFromFile.add_sim_inspirals(simInspiralTable) if coincs: coincs.extend(coincFromFile) else: coincs = coincFromFile doc.unlink() return coincs, sims
def check_segment_availability(grb_name, grb_time, query_start, query_end, offset, ifo, segmentName): ''' Searches +/- offset from GRB time to download the latest segment lists then extracts times and puts them into a txt file. ''' args = { 'grb_name': grb_name, 'query_start': query_start, 'query_end': query_end, 'ifo': ifo, 'segmentName': segmentName } cmd = "ligolw_segment_query --database --query-segments --include-segments '{segmentName}' --gps-start-time {query_start} --gps-end-time {query_end} > ./segments{ifo}_grb{grb_name}.xml".format( **args) print '>>', cmd print process = subprocess.Popen([cmd], shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) output, err = process.communicate() # try to open the file try: doc = utils.load_filename( "segments{ifo}_grb{grb_name}.xml".format(**args), contenthandler=lsctables.use_in(ligolw.LIGOLWContentHandler)) except: raise IOError, "Error reading file: segments{ifo}_grb{grb_name}.xml".format( **args) # extract the segment list from segment:table and store in a txt file segs = table.get_table(doc, "segment") seglist = segments.segmentlist( segments.segment(s.start_time, s.end_time) for s in segs) segmentsUtils.tosegwizard(file( "{ifo}-science_grb{grb_name}.txt".format(**args), 'w'), seglist, header=True) print ">> %s segments +/-%ds from %ds found:" % (ifo, offset, grb_time) for s in segs: print "Start:", s.start_time, "End:", s.end_time, "Duration:", s.end_time - s.start_time print return
def select_segments_by_definer(segment_file, segment_name=None, ifo=None): """ Return the list of segments that match the segment name Parameters ---------- segment_file: str path to segment xml file segment_name: str Name of segment ifo: str, optional Returns ------- seg: list of segments """ from glue.ligolw.ligolw import LIGOLWContentHandler as h lsctables.use_in(h) indoc = ligolw_utils.load_filename(segment_file, False, contenthandler=h) segment_table = table.get_table(indoc, 'segment') seg_def_table = table.get_table(indoc, 'segment_definer') def_ifos = seg_def_table.getColumnByName('ifos') def_names = seg_def_table.getColumnByName('name') def_ids = seg_def_table.getColumnByName('segment_def_id') valid_id = [] for def_ifo, def_name, def_id in zip(def_ifos, def_names, def_ids): if ifo and ifo != def_ifo: continue if segment_name and segment_name != def_name: continue valid_id += [def_id] start = numpy.array(segment_table.getColumnByName('start_time')) start_ns = numpy.array(segment_table.getColumnByName('start_time_ns')) end = numpy.array(segment_table.getColumnByName('end_time')) end_ns = numpy.array(segment_table.getColumnByName('end_time_ns')) start, end = start + 1e-9 * start_ns, end + 1e-9 * end_ns did = segment_table.getColumnByName('segment_def_id') keep = numpy.array([d in valid_id for d in did]) if sum(keep) > 0: return start_end_to_segments(start[keep], end[keep]) else: return segmentlist([])
def get_segments_from_xml(filename): """ Return a segmentlist of every segment in an XML file with a segments table. """ # read XML file seg_xml = utils.load_filename(filename, contenthandler=DefaultContentHandler) # get the segment table seg_table = lsctables.SegmentTable.get_table(seg_xml) # loop over segments table to get all the segments segs = segments.segmentlist() for seg in seg_table: segs.append(segments.segment(seg.start_time, seg.end_time)) return segs
def getAuxChannels(self,inputList): intermediateTable = {'type':[],'ifo':[],'qscan_time':[],'qscan_dir':[],'channel_name':[],'peak_time':[],'peak_frequency':[],'peak_q':[],'peak_significance':[],'peak_amplitude':[]} try: doc = utils.load_filename(inputList[0] + "/summary.xml",verbose=True,gz=False,xmldoc=None,contenthandler=None) qscanTable = table.get_table(doc, "qscan:summary:table") except: print >> sys.stderr, "failed to read" + inputList[0] + "/summary.xml" return intermediateTable for channel in qscanTable: for param in self.paramMaps: intermediateTable[param[0]].append(eval('channel.' + param[1])) intermediateTable['qscan_dir'].append(inputList[0]) #if len(inputList) == 4: intermediateTable['qscan_time'].append(inputList[1]) intermediateTable['type'].append(inputList[2]) intermediateTable['ifo'].append(inputList[3]) return intermediateTable
def select_segments_by_definer(segment_file, segment_name=None, ifo=None): """ Return the list of segments that match the segment name Parameters ---------- segment_file: str path to segment xml file segment_name: str Name of segment ifo: str, optional Returns ------- seg: list of segments """ from glue.ligolw.ligolw import LIGOLWContentHandler as h; lsctables.use_in(h) indoc = ligolw_utils.load_filename(segment_file, False, contenthandler=h) segment_table = table.get_table(indoc, 'segment') seg_def_table = table.get_table(indoc, 'segment_definer') def_ifos = seg_def_table.getColumnByName('ifos') def_names = seg_def_table.getColumnByName('name') def_ids = seg_def_table.getColumnByName('segment_def_id') valid_id = [] for def_ifo, def_name, def_id in zip(def_ifos, def_names, def_ids): if ifo and ifo != def_ifo: continue if segment_name and segment_name != def_name: continue valid_id += [def_id] start = numpy.array(segment_table.getColumnByName('start_time')) start_ns = numpy.array(segment_table.getColumnByName('start_time_ns')) end = numpy.array(segment_table.getColumnByName('end_time')) end_ns = numpy.array(segment_table.getColumnByName('end_time_ns')) start, end = start + 1e-9 * start_ns, end + 1e-9 * end_ns did = segment_table.getColumnByName('segment_def_id') keep = numpy.array([d in valid_id for d in did]) if sum(keep) > 0: return start_end_to_segments(start[keep], end[keep]) else: return segmentlist([])
def __init__(self, filename, filter_length, delta_f, f_lower, dtype, out=None, approximant=None, **kwds): self.out = out self.dtype = dtype self.f_lower = f_lower self.approximant = approximant self.filename = filename self.delta_f = delta_f self.N = (filter_length - 1 ) * 2 self.delta_t = 1.0 / (self.N * self.delta_f) self.filter_length = filter_length self.kmin = int(f_lower / delta_f) self.indoc = ligolw_utils.load_filename( filename, False, contenthandler=LIGOLWContentHandler) self.table = table.get_table( self.indoc, lsctables.SnglInspiralTable.tableName) self.extra_args = kwds
def load_likelihood_data(filenames, verbose = False): coinc_params = None seglists = None for n, filename in enumerate(filenames, 1): if verbose: print >>sys.stderr, "%d/%d:" % (n, len(filenames)), xmldoc = ligolw_utils.load_filename(filename, verbose = verbose, contenthandler = StringCoincParamsDistributions.contenthandler) this_coinc_params = StringCoincParamsDistributions.from_xml(xmldoc, u"string_cusp_likelihood") this_seglists = lsctables.SearchSummaryTable.get_table(xmldoc).get_out_segmentlistdict(set([this_coinc_params.process_id])).coalesce() xmldoc.unlink() if coinc_params is None: coinc_params = this_coinc_params else: coinc_params += this_coinc_params if seglists is None: seglists = this_seglists else: seglists |= this_seglists return coinc_params, seglists
def load_time_slides(filename, verbose = False, gz = False): """ Load a time_slide table from the LIGO Light Weight XML file named filename, or stdin if filename is None. Extra verbosity is printed if verbose is True, and the file is gzip decompressed while reading if gz is Tue. The output is returned as a dictionary, mapping each time slide ID to a dictionary providing a mapping of instrument to offset for that time slide. Note that a side effect of this function is that the ID generator associated with the TimeSlideTable class in glue.ligolw.lsctables is synchronized with the result, so that the next ID it generates will be immediately following the IDs listed in the dictionary returned by this function. """ time_slide_table = table.get_table(utils.load_filename(filename, verbose = verbose, gz = (filename or "stdin")[-3:] == ".gz"), lsctables.TimeSlideTable.tableName) time_slides = time_slide_table.as_dict() time_slide_table.sync_next_id() return time_slides
def load_likelihood_data(filenames, verbose = False): coinc_params = None seglists = None for n, filename in enumerate(filenames, 1): if verbose: print("%d/%d:" % (n, len(filenames)), end=' ', file=sys.stderr) xmldoc = ligolw_utils.load_filename(filename, verbose = verbose, contenthandler = StringCoincParamsDistributions.LIGOLWContentHandler) this_coinc_params = StringCoincParamsDistributions.from_xml(xmldoc, u"string_cusp_likelihood") this_seglists = lsctables.SearchSummaryTable.get_table(xmldoc).get_out_segmentlistdict(lsctables.ProcessTable.get_table(xmldoc).get_ids_by_program(u"lalapps_string_meas_likelihood")).coalesce() xmldoc.unlink() if coinc_params is None: coinc_params = this_coinc_params else: coinc_params += this_coinc_params if seglists is None: seglists = this_seglists else: seglists |= this_seglists return coinc_params, seglists
def readCoincInspiralFromFiles(fileList,statistic=None): """ read in the Sngl and SimInspiralTables from a list of files if Sngls are found, construct coincs, add injections (if any) also return Sims (if any) @param fileList: list of input files @param statistic: instance of coincStatistic, to use in creating coincs """ if not fileList: return coincInspiralTable(), None if not (isinstance(statistic,coincStatistic)): raise TypeError, "invalid statistic, must be coincStatistic" sims = None coincs = None lsctables.use_in(ExtractCoincInspiralTableLIGOLWContentHandler) for thisFile in fileList: doc = utils.load_filename(thisFile, gz = (thisFile or "stdin").endswith(".gz"), contenthandler=ExtractCoincInspiralTableLIGOLWContentHandler) # extract the sim inspiral table try: simInspiralTable = \ table.get_table(doc, lsctables.SimInspiralTable.tableName) if sims: sims.extend(simInspiralTable) else: sims = simInspiralTable except: simInspiralTable = None # extract the sngl inspiral table, construct coincs try: snglInspiralTable = \ table.get_table(doc, lsctables.SnglInspiralTable.tableName) except: snglInspiralTable = None if snglInspiralTable: coincFromFile = coincInspiralTable(snglInspiralTable,statistic) if simInspiralTable: coincFromFile.add_sim_inspirals(simInspiralTable) if coincs: coincs.extend(coincFromFile) else: coincs = coincFromFile doc.unlink() return coincs, sims
def ReadMultiInspiralFromFiles(fileList): """ Read the multiInspiral tables from a list of files @param fileList: list of input files """ if not fileList: return multiInspiralTable(), None multis = None for thisFile in fileList: doc = utils.load_filename(thisFile, gz=(thisFile or "stdin").endswith(".gz"), contenthandler = lsctables.use_in(ligolw.LIGOLWContentHandler)) # extract the multi inspiral table try: multiInspiralTable = lsctables.MultiInspiralTable.get_table(doc) if multis: multis.extend(multiInspiralTable) else: multis = multiInspiralTable except: multiInspiralTable = None return multis
def query_segments_xml(xml_location, gps_start, gps_end, spec): """ Retrieve the segment table from a location, and clip segments to (gps_start, gps_end). If spec is given, retrieve only segments with this definer, otherwise, get all of them. """ if spec is None: spec = True else: # ifo, definer, version = spec.split(":") definer = spec.split(":") ifo, definer, version = definer[0], ":".join(definer[1:-1]), definer[-1] xmldoc = utils.load_filename(xml_location) segment_definer = table.get_table(xmldoc, lsctables.SegmentDefTable.tableName) # FIXME: ifo in ifos? What does a segment for a set of ifos even mean? seg_def_id = [sd.segment_def_id for sd in segment_definer if spec and ifo in sd.get_ifos() and definer == sd.name] if len(seg_def_id) != 1: raise ValueError("Need exactly one definer row for %s:%s:%s, got %d" % (ifo, definer, version, len(seg_def_id))) seg_def_id = seg_def_id[0] segment = table.get_table(xmldoc, lsctables.SegmentTable.tableName) return segmentlist([s.get() for s in segment if s.segment_def_id == seg_def_id])