def gen_likelihood_control(coinc_params_distributions, seglists, name=u"lalapps_burca_tailor", comment=u""): xmldoc = ligolw.Document() node = xmldoc.appendChild(ligolw.LIGO_LW()) process = ligolw_process.register_to_xmldoc(xmldoc, program=process_program_name, paramdict={}, version=__version__, cvs_repository="lscsoft", cvs_entry_time=__date__, comment=comment) coinc_params_distributions.process_id = process.process_id ligolw_search_summary.append_search_summary(xmldoc, process, ifos=seglists.keys(), inseg=seglists.extent_all(), outseg=seglists.extent_all()) node.appendChild(coinc_params_distributions.to_xml(name)) ligolw_process.set_process_end_time(process) return xmldoc
def create_process_table(document, program_name=None, detectors=None, comment=None, options=None): """Create a LIGOLW process table with sane defaults, add it to a LIGOLW document, and return it. """ if program_name is None: program_name = os.path.basename(sys.argv[0]) if options is None: options = {} # ligo.lw does not like `cvs_entry_time` being an empty string cvs_entry_time = pycbc_version.date or None process = ligolw_process.register_to_xmldoc(document, program_name, options, version=pycbc_version.version, cvs_repository='pycbc/' + pycbc_version.git_branch, cvs_entry_time=cvs_entry_time, instruments=detectors, comment=comment) return process
def append_process(xmldoc, cluster_algorithm, comment): return ligolw_process.register_to_xmldoc( xmldoc, program=process_program_name, paramdict={"cluster_algorithm": cluster_algorithm}, version=__version__, cvs_repository=u"lscsoft", cvs_entry_time=__date__, comment=comment)
def register_to_xmldoc(xmldoc, parser, opts, **kwargs): from ligo.lw.utils import process params = { key: _sanitize_arg_value_for_xmldoc(value) for key, value in opts.__dict__.items() } return process.register_to_xmldoc(xmldoc, parser.prog, params, **kwargs, version=version_string)
def append_process(xmldoc, cluster_algorithm, comment): return ligolw_process.register_to_xmldoc( xmldoc, program = process_program_name, paramdict = { "cluster_algorithm": cluster_algorithm }, version = __version__, cvs_repository = u"lscsoft", cvs_entry_time = __date__, comment = comment )
def append_process(xmldoc, match_algorithm, comment): """ Convenience wrapper for adding process metadata to the document. """ return ligolw_process.register_to_xmldoc( xmldoc, program=process_program_name, paramdict={"match_algorithm": match_algorithm}, version=__version__, cvs_repository=u"lscsoft", cvs_entry_time=__date__, comment=comment)
def gen_likelihood_control(coinc_params_distributions, seglists, name = u"lalapps_burca_tailor", comment = u""): xmldoc = ligolw.Document() node = xmldoc.appendChild(ligolw.LIGO_LW()) process = ligolw_process.register_to_xmldoc(xmldoc, program = process_program_name, paramdict = {}, version = __version__, cvs_repository = "lscsoft", cvs_entry_time = __date__, comment = comment) coinc_params_distributions.process_id = process.process_id ligolw_search_summary.append_search_summary(xmldoc, process, ifos = seglists.keys(), inseg = seglists.extent_all(), outseg = seglists.extent_all()) node.appendChild(coinc_params_distributions.to_xml(name)) ligolw_process.set_process_end_time(process) return xmldoc
def new_doc(comment=None, **kwargs): doc = ligolw.Document() doc.appendChild(ligolw.LIGO_LW()) process = ligolw_process.register_to_xmldoc( doc, program=u"lalapps_gen_timeslides", paramdict=kwargs, version=__version__, cvs_repository=u"lscsoft", cvs_entry_time=__date__, comment=comment) doc.childNodes[0].appendChild(lsctables.New(lsctables.TimeSlideTable)) return doc, process
def append_process(xmldoc, match_algorithm, comment): """ Convenience wrapper for adding process metadata to the document. """ return ligolw_process.register_to_xmldoc( xmldoc, program = process_program_name, paramdict = { "match_algorithm": match_algorithm }, version = __version__, cvs_repository = u"lscsoft", cvs_entry_time = __date__, comment = comment )
def new_doc(comment = None, **kwargs): doc = ligolw.Document() doc.appendChild(ligolw.LIGO_LW()) process = ligolw_process.register_to_xmldoc( doc, program = u"lalapps_gen_timeslides", paramdict = kwargs, version = __version__, cvs_repository = u"lscsoft", cvs_entry_time = __date__, comment = comment ) timeslidetable = lsctables.New(lsctables.TimeSlideTable) doc.childNodes[0].appendChild(timeslidetable) return doc, process
def ligolw_bucut(xmldoc, burst_test_func, veto_segments=segments.segmentlistdict(), del_non_coincs=False, del_skipped_injections=False, program=None, comment=None, verbose=False): process = ligolw_process.register_to_xmldoc(xmldoc, process_program_name, paramdict, version=__version__, cvs_repository=u"lscsoft", cvs_entry_time=__date__, comment=comment) contents = DocContents(xmldoc, program) apply_filters(contents, burst_test_func, veto_segments, del_non_coincs=del_non_coincs, del_skipped_injections=del_skipped_injections, verbose=verbose) seg = contents.outsegs.extent_all() ligolw_search_summary.append_search_summary(xmldoc, process, inseg=seg, outseg=seg, nevents=len( contents.snglbursttable)) ligolw_process.set_process_end_time(process) return xmldoc
def gen_psd_xmldoc(self): xmldoc = lal.series.make_psd_xmldoc(self.psds) process = ligolw_process.register_to_xmldoc(xmldoc, "snax", {}) ligolw_process.set_process_end_time(process) return xmldoc
options, filenames = parse_command_line() # # use the time-slide file to start the output document # xmldoc = ligolw_utils.load_filename(options.time_slide_xml, verbose=options.verbose, contenthandler=LIGOLWContentHandler) # # add our metadata # process = ligolw_process.register_to_xmldoc(xmldoc, u"lalapps_binj_pic", options.options_dict, version=git_version.version) # # use whatever time slide vector comes first in the table (lazy) # time_slide_table = lsctables.TimeSlideTable.get_table(xmldoc) time_slide_id = time_slide_table[0].time_slide_id if options.verbose: print("associating injections with time slide (%d) %s" % (time_slide_id, time_slide_table.as_dict()[time_slide_id]), file=sys.stderr) # # find or add a sim_burst table
if not options.force: if options.verbose: print("skipping", file=sys.stderr) continue if options.verbose: print("continuing by --force", file=sys.stderr) # # Add an entry to the process table. # process = ligolw_process.register_to_xmldoc( xmldoc, process_program_name, process_params, comment = options.comment, version = __version__, cvs_repository = u"lscsoft", cvs_entry_time = __date__ ) # # LAL writes all triggers with event_id = 0. Detect this and barf # on it. # tbl = lsctables.SnglInspiralTable.get_table(xmldoc) assert len(set(tbl.getColumnByName("event_id"))) == len(tbl), "degenerate sngl_inspiral event_id detected" # # Extract veto segments if present.
# get working copy of database # if options.verbose: print >> sys.stderr, "%d/%d: %s" % (n, len(filename), filename) working_filename = dbtables.get_connection_filename( filename, tmp_path=options.tmp_space, verbose=options.verbose) connection = sqlite3.connect(str(working_filename)) # # record our passage # xmldoc = dbtables.get_xml(connection) process = ligolw_process.register_to_xmldoc( xmldoc, u"lalapps_string_compute_fapfar", process_params) # # assign FAPs and FARs # fapfar.assign_fapfars(connection) # # done, restore file to original location # ligolw_process.set_process_end_time(process) connection.cursor().execute( "UPDATE process SET end_time = ? WHERE process_id == ?", (process.end_time, process.process_id))
def output_sngl_inspiral_table(outputFile, tempBank, metricParams, ethincaParams, programName="", optDict=None, outdoc=None, **kwargs): """ Function that converts the information produced by the various pyCBC bank generation codes into a valid LIGOLW xml file containing a sngl_inspiral table and outputs to file. Parameters ----------- outputFile : string Name of the file that the bank will be written to tempBank : iterable Each entry in the tempBank iterable should be a sequence of [mass1,mass2,spin1z,spin2z] in that order. metricParams : metricParameters instance Structure holding all the options for construction of the metric and the eigenvalues, eigenvectors and covariance matrix needed to manipulate the space. ethincaParams: {ethincaParameters instance, None} Structure holding options relevant to the ethinca metric computation including the upper frequency cutoff to be used for filtering. NOTE: The computation is currently only valid for non-spinning systems and uses the TaylorF2 approximant. programName (key-word-argument) : string Name of the executable that has been run optDict (key-word argument) : dictionary Dictionary of the command line arguments passed to the program outdoc (key-word argument) : ligolw xml document If given add template bank to this representation of a xml document and write to disk. If not given create a new document. kwargs : key-word arguments All other key word arguments will be passed directly to ligolw_process.register_to_xmldoc """ if optDict is None: optDict = {} if outdoc is None: outdoc = ligolw.Document() outdoc.appendChild(ligolw.LIGO_LW()) # get IFO to put in search summary table ifos = [] if 'channel_name' in optDict.keys(): if optDict['channel_name'] is not None: ifos = [optDict['channel_name'][0:2]] proc_id = ligolw_process.register_to_xmldoc(outdoc, programName, optDict, instruments=ifos, **kwargs).process_id sngl_inspiral_table = convert_to_sngl_inspiral_table(tempBank, proc_id) # Calculate Gamma components if needed if ethincaParams is not None: if ethincaParams.doEthinca: for sngl in sngl_inspiral_table: # Set tau_0 and tau_3 values needed for the calculation of # ethinca metric distances (sngl.tau0, sngl.tau3) = pnutils.mass1_mass2_to_tau0_tau3( sngl.mass1, sngl.mass2, metricParams.f0) fMax_theor, GammaVals = calculate_ethinca_metric_comps( metricParams, ethincaParams, sngl.mass1, sngl.mass2, spin1z=sngl.spin1z, spin2z=sngl.spin2z, full_ethinca=ethincaParams.full_ethinca) # assign the upper frequency cutoff and Gamma0-5 values sngl.f_final = fMax_theor for i in range(len(GammaVals)): setattr(sngl, "Gamma" + str(i), GammaVals[i]) # If Gamma metric components are not wanted, assign f_final from an # upper frequency cutoff specified in ethincaParams elif ethincaParams.cutoff is not None: for sngl in sngl_inspiral_table: sngl.f_final = pnutils.frequency_cutoff_from_name( ethincaParams.cutoff, sngl.mass1, sngl.mass2, sngl.spin1z, sngl.spin2z) # set per-template low-frequency cutoff if 'f_low_column' in optDict and 'f_low' in optDict and \ optDict['f_low_column'] is not None: for sngl in sngl_inspiral_table: setattr(sngl, optDict['f_low_column'], optDict['f_low']) outdoc.childNodes[0].appendChild(sngl_inspiral_table) # get times to put in search summary table start_time = 0 end_time = 0 if 'gps_start_time' in optDict.keys() and 'gps_end_time' in optDict.keys(): start_time = optDict['gps_start_time'] end_time = optDict['gps_end_time'] # make search summary table search_summary_table = lsctables.New(lsctables.SearchSummaryTable) search_summary = return_search_summary(start_time, end_time, len(sngl_inspiral_table), ifos, **kwargs) search_summary_table.append(search_summary) outdoc.childNodes[0].appendChild(search_summary_table) # write the xml doc to disk ligolw_utils.write_filename(outdoc, outputFile, gz=outputFile.endswith('.gz'))
def __init__(self, ifos, coinc_results, **kwargs): """Initialize a ligolw xml representation of a zerolag trigger for upload from pycbc live to gracedb. Parameters ---------- ifos: list of strs A list of the ifos participating in this trigger. coinc_results: dict of values A dictionary of values. The format is defined in pycbc/events/coinc.py and matches the on disk representation in the hdf file for this time. psds: dict of FrequencySeries Dictionary providing PSD estimates for all involved detectors. low_frequency_cutoff: float Minimum valid frequency for the PSD estimates. high_frequency_cutoff: float, optional Maximum frequency considered for the PSD estimates. Default None. followup_data: dict of dicts, optional Dictionary providing SNR time series for each detector, to be used in sky localization with BAYESTAR. The format should be `followup_data['H1']['snr_series']`. More detectors can be present than given in `ifos`. If so, the extra detectors will only be used for sky localization. channel_names: dict of strings, optional Strain channel names for each detector. Will be recorded in the sngl_inspiral table. mc_area_args: dict of dicts, optional Dictionary providing arguments to be used in source probability estimation with pycbc/mchirp_area.py """ self.template_id = coinc_results['foreground/%s/template_id' % ifos[0]] self.coinc_results = coinc_results self.ifos = ifos # remember if this should be marked as HWINJ self.is_hardware_injection = ('HWINJ' in coinc_results and coinc_results['HWINJ']) # Check if we need to apply a time offset (this may be permerger) self.time_offset = 0 rtoff = 'foreground/{}/time_offset'.format(ifos[0]) if rtoff in coinc_results: self.time_offset = coinc_results[rtoff] if 'followup_data' in kwargs: fud = kwargs['followup_data'] assert len({fud[ifo]['snr_series'].delta_t for ifo in fud}) == 1, \ "delta_t for all ifos do not match" self.snr_series = {ifo: fud[ifo]['snr_series'] for ifo in fud} usable_ifos = fud.keys() followup_ifos = list(set(usable_ifos) - set(ifos)) for ifo in self.snr_series: self.snr_series[ifo].start_time += self.time_offset else: self.snr_series = None usable_ifos = ifos followup_ifos = [] # Set up the bare structure of the xml document outdoc = ligolw.Document() outdoc.appendChild(ligolw.LIGO_LW()) # ligo.lw does not like `cvs_entry_time` being an empty string cvs_entry_time = pycbc_version.date or None proc_id = ligolw_process.register_to_xmldoc( outdoc, 'pycbc', {}, instruments=usable_ifos, comment='', version=pycbc_version.version, cvs_repository='pycbc/' + pycbc_version.git_branch, cvs_entry_time=cvs_entry_time).process_id # Set up coinc_definer table coinc_def_table = lsctables.New(lsctables.CoincDefTable) coinc_def_id = lsctables.CoincDefID(0) coinc_def_row = lsctables.CoincDef() coinc_def_row.search = "inspiral" coinc_def_row.description = "sngl_inspiral<-->sngl_inspiral coincs" coinc_def_row.coinc_def_id = coinc_def_id coinc_def_row.search_coinc_type = 0 coinc_def_table.append(coinc_def_row) outdoc.childNodes[0].appendChild(coinc_def_table) # Set up coinc inspiral and coinc event tables coinc_id = lsctables.CoincID(0) coinc_event_table = lsctables.New(lsctables.CoincTable) coinc_event_row = lsctables.Coinc() coinc_event_row.coinc_def_id = coinc_def_id coinc_event_row.nevents = len(usable_ifos) coinc_event_row.instruments = ','.join(usable_ifos) coinc_event_row.time_slide_id = lsctables.TimeSlideID(0) coinc_event_row.process_id = proc_id coinc_event_row.coinc_event_id = coinc_id coinc_event_row.likelihood = 0. coinc_event_table.append(coinc_event_row) outdoc.childNodes[0].appendChild(coinc_event_table) # Set up sngls sngl_inspiral_table = lsctables.New(lsctables.SnglInspiralTable) coinc_event_map_table = lsctables.New(lsctables.CoincMapTable) sngl_populated = None network_snrsq = 0 for sngl_id, ifo in enumerate(usable_ifos): sngl = return_empty_sngl(nones=True) sngl.event_id = lsctables.SnglInspiralID(sngl_id) sngl.process_id = proc_id sngl.ifo = ifo names = [ n.split('/')[-1] for n in coinc_results if 'foreground/%s' % ifo in n ] for name in names: val = coinc_results['foreground/%s/%s' % (ifo, name)] if name == 'end_time': val += self.time_offset sngl.end = lal.LIGOTimeGPS(val) else: try: setattr(sngl, name, val) except AttributeError: pass if sngl.mass1 and sngl.mass2: sngl.mtotal, sngl.eta = pnutils.mass1_mass2_to_mtotal_eta( sngl.mass1, sngl.mass2) sngl.mchirp, _ = pnutils.mass1_mass2_to_mchirp_eta( sngl.mass1, sngl.mass2) sngl_populated = sngl if sngl.snr: sngl.eff_distance = (sngl.sigmasq)**0.5 / sngl.snr network_snrsq += sngl.snr**2.0 if 'channel_names' in kwargs and ifo in kwargs['channel_names']: sngl.channel = kwargs['channel_names'][ifo] sngl_inspiral_table.append(sngl) # Set up coinc_map entry coinc_map_row = lsctables.CoincMap() coinc_map_row.table_name = 'sngl_inspiral' coinc_map_row.coinc_event_id = coinc_id coinc_map_row.event_id = sngl.event_id coinc_event_map_table.append(coinc_map_row) if self.snr_series is not None: snr_series_to_xml(self.snr_series[ifo], outdoc, sngl.event_id) # set merger time to the average of the ifo peaks self.merger_time = numpy.mean([ coinc_results['foreground/{}/end_time'.format(ifo)] for ifo in ifos ]) + self.time_offset # for subthreshold detectors, respect BAYESTAR's assumptions and checks bayestar_check_fields = ('mass1 mass2 mtotal mchirp eta spin1x ' 'spin1y spin1z spin2x spin2y spin2z').split() for sngl in sngl_inspiral_table: if sngl.ifo in followup_ifos: for bcf in bayestar_check_fields: setattr(sngl, bcf, getattr(sngl_populated, bcf)) sngl.end = lal.LIGOTimeGPS(self.merger_time) outdoc.childNodes[0].appendChild(coinc_event_map_table) outdoc.childNodes[0].appendChild(sngl_inspiral_table) # Set up the coinc inspiral table coinc_inspiral_table = lsctables.New(lsctables.CoincInspiralTable) coinc_inspiral_row = lsctables.CoincInspiral() # This seems to be used as FAP, which should not be in gracedb coinc_inspiral_row.false_alarm_rate = 0 coinc_inspiral_row.minimum_duration = 0. coinc_inspiral_row.instruments = tuple(usable_ifos) coinc_inspiral_row.coinc_event_id = coinc_id coinc_inspiral_row.mchirp = sngl_populated.mchirp coinc_inspiral_row.mass = sngl_populated.mtotal coinc_inspiral_row.end_time = sngl_populated.end_time coinc_inspiral_row.end_time_ns = sngl_populated.end_time_ns coinc_inspiral_row.snr = network_snrsq**0.5 far = 1.0 / (lal.YRJUL_SI * coinc_results['foreground/ifar']) coinc_inspiral_row.combined_far = far coinc_inspiral_table.append(coinc_inspiral_row) outdoc.childNodes[0].appendChild(coinc_inspiral_table) # append the PSDs self.psds = kwargs['psds'] psds_lal = {} for ifo in self.psds: psd = self.psds[ifo] kmin = int(kwargs['low_frequency_cutoff'] / psd.delta_f) fseries = lal.CreateREAL8FrequencySeries( "psd", psd.epoch, kwargs['low_frequency_cutoff'], psd.delta_f, lal.StrainUnit**2 / lal.HertzUnit, len(psd) - kmin) fseries.data.data = psd.numpy()[kmin:] / pycbc.DYN_RANGE_FAC**2.0 psds_lal[ifo] = fseries make_psd_xmldoc(psds_lal, outdoc) # source probabilities estimation if 'mc_area_args' in kwargs: eff_distances = [sngl.eff_distance for sngl in sngl_inspiral_table] probabilities = calc_probabilities(coinc_inspiral_row.mchirp, coinc_inspiral_row.snr, min(eff_distances), kwargs['mc_area_args']) self.probabilities = probabilities else: self.probabilities = None self.outdoc = outdoc self.time = sngl_populated.end
# # FIXME: don't hard-code instruments distributions = stringutils.StringCoincParamsDistributions(["H1", "L1", "V1"]) segs = segments.segmentlistdict() # # Start output document # xmldoc = ligolw.Document() xmldoc.appendChild(ligolw.LIGO_LW()) process = ligolw_process.register_to_xmldoc( xmldoc, program=u"lalapps_string_meas_likelihood", paramdict=paramdict, version=__version__, cvs_repository="lscsoft", cvs_entry_time=__date__, comment=u"") # # Iterate over files # for n, filename in enumerate(filenames): # # Open the database file. # if options.verbose: print("%d/%d: %s" % (n + 1, len(filenames), filename), file=sys.stderr)
file=sys.stderr) if not options.force: if options.verbose: print("skipping", file=sys.stderr) continue if options.verbose: print("continuing by --force", file=sys.stderr) # # Add an entry to the process table. # process = ligolw_process.register_to_xmldoc(xmldoc, process_program_name, process_params, comment=options.comment, version=__version__, cvs_repository=u"lscsoft", cvs_entry_time=__date__) # # LAL writes all triggers with event_id = 0. Detect this and barf # on it. # tbl = lsctables.SnglInspiralTable.get_table(xmldoc) assert len(set(tbl.getColumnByName("event_id"))) == len( tbl), "degenerate sngl_inspiral event_id detected" # # Extract veto segments if present.
workflow, scienceSegs, dfDir, segsList) # This is needed to know what times will be analysed by daily ahope # Template bank stuff banks = _workflow.setup_tmpltbank_workflow(workflow, scienceSegs, datafinds, dfDir) # Do matched-filtering insps = _workflow.setup_matchedfltr_workflow(workflow, scienceSegs, datafinds, banks, dfDir) # Now construct the summary XML file outdoc = ligolw.Document() outdoc.appendChild(ligolw.LIGO_LW()) # FIXME: PROGRAM NAME and dictionary of opts should be variables defined up above proc_id = ligolw_process.register_to_xmldoc(outdoc, 'dayhopetest', vars(args)).process_id for ifo in workflow.ifos: # Lets get the segment lists we need segIfoFiles = segsList.find_output_with_ifo(ifo) # SCIENCE sciSegFile = segIfoFiles.find_output_with_tag('SCIENCE') assert (len(sciSegFile) == 1) sciSegFile = sciSegFile[0] sciSegs = sciSegFile.segmentList # SCIENCE_OK sciokSegFile = segIfoFiles.find_output_with_tag('SCIENCE_OK') assert (len(sciokSegFile) == 1) sciokSegFile = sciokSegFile[0] sciokSegs = sciokSegFile.segmentList # SCIENCE_AVAILABLE sciavailableSegFile = segIfoFiles.find_output_with_tag('SCIENCE_AVAILABLE')
# Main # # ============================================================================= # options, filenames = parse_command_line() if options.verbose: print("time-frequency tiles have %g degrees of freedom" % (2 * options.delta_t * options.delta_f), file=sys.stderr) xmldoc = ligolw.Document() xmldoc.appendChild(ligolw.LIGO_LW()) process = ligolw_process.register_to_xmldoc(xmldoc, u"lalapps_binj_pic", options.options_dict, version = git_version.version) time_slide_table = xmldoc.childNodes[-1].appendChild(lsctables.TimeSlideTable.get_table(ligolw_utils.load_filename(options.time_slide_xml, verbose = options.verbose, contenthandler = LIGOLWContentHandler))) time_slide_id = time_slide_table[0].time_slide_id if options.verbose: print("associating injections with time slide ID \"%s\": %s" % (time_slide_id, time_slide_table.as_dict()[time_slide_id]), file=sys.stderr) for row in time_slide_table: row.process_id = process.process_id sim_burst_tbl = xmldoc.childNodes[-1].appendChild(lsctables.New(lsctables.SimBurstTable, ["process_id", "simulation_id", "time_slide_id", "waveform", "waveform_number", "ra", "dec", "psi", "time_geocent_gps", "time_geocent_gps_ns", "duration", "frequency", "bandwidth", "egw_over_rsquared", "pol_ellipse_angle", "pol_ellipse_e"])) for filename in filenames: if options.verbose: print("loading %s ..." % filename, file=sys.stderr) img = Image.open(filename) width, height = img.size
# # FIXME: don't hard-code instruments distributions = stringutils.StringCoincParamsDistributions(["H1", "L1", "V1"]) segs = segments.segmentlistdict() # # Start output document # xmldoc = ligolw.Document() xmldoc.appendChild(ligolw.LIGO_LW()) process = ligolw_process.register_to_xmldoc(xmldoc, program = u"lalapps_string_meas_likelihood", paramdict = paramdict, version = __version__, cvs_repository = "lscsoft", cvs_entry_time = __date__, comment = u"") # # Iterate over files # for n, filename in enumerate(filenames): # # Open the database file. # if options.verbose: print("%d/%d: %s" % (n + 1, len(filenames), filename), file=sys.stderr)