def tosegmentxml(file, segs): """ Write the glue.segments.segmentlist object segs to file object file in xml format with appropriate tables. """ # generate empty document xmldoc = ligolw.Document() xmldoc.appendChild(ligolw.LIGO_LW()) xmldoc.childNodes[-1].appendChild(lsctables.New(lsctables.ProcessTable)) xmldoc.childNodes[-1].appendChild(lsctables.New(lsctables.ProcessParamsTable)) # append process to table process = ligolw_process.append_process(xmldoc,\ program='pylal.dq.dqSegmentUtils',\ version=__version__,\ cvs_repository='lscsoft',\ cvs_entry_time=__date__) gpssegs = segments.segmentlist() for seg in segs: gpssegs.append(segments.segment(LIGOTimeGPS(seg[0]), LIGOTimeGPS(seg[1]))) # append segs and seg definer segments_tables = ligolw_segments.LigolwSegments(xmldoc) segments_tables.add(ligolw_segments.LigolwSegmentList(active=gpssegs)) # finalise segments_tables.coalesce() segments_tables.optimize() segments_tables.finalize(process) ligolw_process.set_process_end_time(process) # write file utils.write_fileobj(xmldoc, file, gz=False)
def write_tables(target, tables, append=False, overwrite=False, **kwargs): """Write an LIGO_LW table to file Parameters ---------- target : `str`, `file`, :class:`~glue.ligolw.ligolw.Document` the file or document to write into tables : `list`, `tuple` of :class:`~glue.ligolw.table.Table` the tables to write append : `bool`, optional, default: `False` if `True`, append to an existing file/table, otherwise `overwrite` overwrite : `bool`, optional, default: `False` if `True`, delete an existing instance of the table type, otherwise append new rows **kwargs other keyword arguments to pass to :func:`~glue.ligolw.utils.load_filename`, or :func:`~glue.ligolw.utils.load_fileobj` as appropriate """ from glue.ligolw.ligolw import (Document, LIGO_LW, LIGOLWContentHandler) from glue.ligolw import utils as ligolw_utils # allow writing directly to XML if isinstance(target, (Document, LIGO_LW)): xmldoc = target # open existing document, if possible elif append and not overwrite: xmldoc = open_xmldoc(target, contenthandler=kwargs.pop('contenthandler', LIGOLWContentHandler)) # fail on existing document and not overwriting elif (not overwrite and isinstance(target, string_types) and os.path.isfile(target)): raise IOError("File exists: {}".format(target)) else: # or create a new document xmldoc = Document() # convert table to format write_tables_to_document(xmldoc, tables, overwrite=overwrite) # write file if isinstance(target, string_types): kwargs.setdefault('gz', target.endswith('.gz')) ligolw_utils.write_filename(xmldoc, target, **kwargs) elif isinstance(target, FILE_LIKE): kwargs.setdefault('gz', target.name.endswith('.gz')) ligolw_utils.write_fileobj(xmldoc, target, **kwargs)
def write_tables(target, tables, append=False, overwrite=False, **kwargs): """Write an LIGO_LW table to file Parameters ---------- target : `str`, `file`, :class:`~glue.ligolw.ligolw.Document` the file or document to write into tables : `list`, `tuple` of :class:`~glue.ligolw.table.Table` the tables to write append : `bool`, optional, default: `False` if `True`, append to an existing file/table, otherwise `overwrite` overwrite : `bool`, optional, default: `False` if `True`, delete an existing instance of the table type, otherwise append new rows **kwargs other keyword arguments to pass to :func:`~glue.ligolw.utils.load_filename`, or :func:`~glue.ligolw.utils.load_fileobj` as appropriate """ from glue.ligolw.ligolw import (Document, LIGO_LW, LIGOLWContentHandler) from glue.ligolw import utils as ligolw_utils # allow writing directly to XML if isinstance(target, (Document, LIGO_LW)): xmldoc = target # open existing document, if possible elif append and not overwrite: xmldoc = open_xmldoc( target, contenthandler=kwargs.pop('contenthandler', LIGOLWContentHandler)) # fail on existing document and not overwriting elif (not overwrite and isinstance(target, string_types) and os.path.isfile(target)): raise IOError("File exists: {}".format(target)) else: # or create a new document xmldoc = Document() # convert table to format write_tables_to_document(xmldoc, tables, overwrite=overwrite) # write file if isinstance(target, string_types): kwargs.setdefault('gz', target.endswith('.gz')) ligolw_utils.write_filename(xmldoc, target, **kwargs) elif isinstance(target, FILE_LIKE): kwargs.setdefault('gz', target.name.endswith('.gz')) ligolw_utils.write_fileobj(xmldoc, target, **kwargs)
def setUp(self): available_detectors = get_available_detectors() available_detectors = [a[0] for a in available_detectors] self.assertTrue('H1' in available_detectors) self.assertTrue('L1' in available_detectors) self.assertTrue('V1' in available_detectors) self.detectors = [Detector(d) for d in ['H1', 'L1', 'V1']] self.sample_rate = 4096. self.earth_time = lal.REARTH_SI / lal.C_SI # create a few random injections self.injections = [] start_time = float(lal.GPSTimeNow()) taper_choices = ('TAPER_NONE', 'TAPER_START', 'TAPER_END', 'TAPER_STARTEND') for i, taper in zip(xrange(20), itertools.cycle(taper_choices)): inj = MyInjection() inj.end_time = start_time + 40000 * i + \ numpy.random.normal(scale=3600) random = numpy.random.uniform inj.mass1 = random(low=1., high=20.) inj.mass2 = random(low=1., high=20.) inj.distance = random(low=0.9, high=1.1) * 1e6 * lal.PC_SI inj.latitude = numpy.arccos(random(low=-1, high=1)) inj.longitude = random(low=0, high=2 * lal.PI) inj.inclination = numpy.arccos(random(low=-1, high=1)) inj.polarization = random(low=0, high=2 * lal.PI) inj.taper = taper self.injections.append(inj) # create LIGOLW document xmldoc = ligolw.Document() xmldoc.appendChild(ligolw.LIGO_LW()) # create sim inspiral table, link it to document and fill it sim_table = lsctables.New(lsctables.SimInspiralTable) xmldoc.childNodes[-1].appendChild(sim_table) for i in xrange(len(self.injections)): row = sim_table.RowType() self.injections[i].fill_sim_inspiral_row(row) row.process_id = 'process:process_id:0' row.simulation_id = 'sim_inspiral:simulation_id:%d' % i sim_table.append(row) # write document to temp file self.inj_file = tempfile.NamedTemporaryFile(suffix='.xml') ligolw_utils.write_fileobj(xmldoc, self.inj_file)
def write_tables(f, tables, append=False, overwrite=False, **kwargs): """Write an LIGO_LW table to file Parameters ---------- f : `str`, `file`, :class:`~glue.ligolw.ligolw.Document` the file or document to write into tables : `list` of :class:`~glue.ligolw.table.Table` the tables to write append : `bool`, optional, default: `False` if `True`, append to an existing file/table, otherwise `overwrite` overwrite : `bool`, optional, default: `False` if `True`, delete an existing instance of the table type, otherwise append new rows """ from glue.ligolw.ligolw import (Document, LIGO_LW, LIGOLWContentHandler) from glue.ligolw import utils as ligolw_utils # allow writing directly to XML if isinstance(f, (Document, LIGO_LW)): xmldoc = f # open existing document, if possible elif append and not overwrite: xmldoc = open_xmldoc(f, contenthandler=kwargs.pop('contenthandler', LIGOLWContentHandler)) # fail on existing document and not overwriting elif not overwrite and isinstance(f, string_types) and os.path.isfile(f): raise IOError("File exists: %s" % f) else: # or create a new document xmldoc = Document() # convert table to format write_tables_to_document(xmldoc, tables, overwrite=overwrite) # write file if isinstance(f, string_types): kwargs.setdefault('gz', f.endswith('.gz')) ligolw_utils.write_filename(xmldoc, f, **kwargs) elif not isinstance(f, Document): kwargs.setdefault('gz', f.name.endswith('.gz')) ligolw_utils.write_fileobj(xmldoc, f, **kwargs)
def upload_xmldoc(gracedb_client, graceid, filename, xmldoc, log_message="A file", tagname=None): logging.info("uploading \"%s\" for %s" % (filename, graceid)) output = io.StringIO() ligolw_utils.write_fileobj(xmldoc, output, gz=filename.endswith(".gz")) response = gracedb_client.writeLog(graceid, log_message, filename=filename, filecontents=output.getvalue(), tagname=tagname) output.close() if response.status != http.client.CREATED: raise Exception("upload of \"%s\" for %s failed: %s" % (filename, graceid, response["error"]))
def tosegmentxml(file, segs): """ Write the glue.segments.segmentlist object segs to file object file in xml format with appropriate tables. """ # generate empty document xmldoc = ligolw.Document() xmldoc.appendChild(ligolw.LIGO_LW()) xmldoc.childNodes[-1].appendChild(lsctables.New(lsctables.ProcessTable)) xmldoc.childNodes[-1].appendChild( lsctables.New(lsctables.ProcessParamsTable)) # append process to table process = ligolw_process.append_process(xmldoc,\ program='pylal.dq.dqSegmentUtils',\ version=__version__,\ cvs_repository='lscsoft',\ cvs_entry_time=__date__) gpssegs = segments.segmentlist() for seg in segs: gpssegs.append( segments.segment(LIGOTimeGPS(seg[0]), LIGOTimeGPS(seg[1]))) # append segs and seg definer segments_tables = ligolw_segments.LigolwSegments(xmldoc) segments_tables.add(ligolw_segments.LigolwSegmentList(active=gpssegs)) # finalise segments_tables.coalesce() segments_tables.optimize() segments_tables.finalize(process) ligolw_process.set_process_end_time(process) # write file with utils.SignalsTrap(): utils.write_fileobj(xmldoc, file, gz=False)
def write_ligolw(flag, fobj, **kwargs): """Write this `DataQualityFlag` to XML in LIGO_LW format """ # if given a Document, just add data if isinstance(fobj, Document): return write_to_xmldoc(flag, fobj, **kwargs) # otherwise build a new Document xmldoc = Document() xmldoc.appendChild(LIGO_LW()) # TODO: add process information write_to_xmldoc(flag, xmldoc) # and write if isinstance(fobj, string_types): return write_filename(xmldoc, fobj, gz=fobj.endswith('.gz')) else: return write_fileobj(xmldoc, fobj, gz=fobj.name.endswith('.gz'))
# Record all sngl_inspiral records and associate them with coincidences. for sngl_inspiral in sngl_inspirals: # Give this sngl_inspiral record an id and add it to the table. sngl_inspiral.event_id = sngl_inspiral_table.get_next_id() sngl_inspiral_table.append(sngl_inspiral) # Add CoincMap entry. coinc_map = lsctables.CoincMap() coinc_map.coinc_event_id = coinc.coinc_event_id coinc_map.table_name = sngl_inspiral_table.tableName coinc_map.event_id = sngl_inspiral.event_id coinc_map_table.append(coinc_map) signal.signal(signal.SIGINT, signal.SIG_DFL) # Record process end time. progress.update(-1, 'writing ' + opts.output.name) ligolw_process.set_process_end_time(process) # Write output file. with ligolw_utils.SignalsTrap(): ligolw_utils.write_fileobj(out_xmldoc, opts.output, gz=(os.path.splitext(opts.output.name)[-1]==".gz")) if handler.interrupted: sys.exit(1)
def pick_coinc(): """Pick a coincidence from the "First Two Years" paper.""" filename = pkg_resources.resource_filename( __name__, '../data/first2years/2016/gstlal.xml.gz') xmldoc = utils.load_filename(filename, contenthandler=ContentHandler) root, = xmldoc.childNodes # Remove unneeded tables for lsctable in (lsctables.FilterTable, lsctables.SegmentTable, lsctables.SegmentDefTable, lsctables.SimInspiralTable, lsctables.SummValueTable, lsctables.SearchSummVarsTable): root.removeChild(lsctable.get_table(xmldoc)) coinc_inspiral_table = table = lsctables.CoincInspiralTable.get_table( xmldoc) # Determine event with most recent sideral time gps_time_now = lal.GPSTimeNow() gmsts = np.asarray([lal.GreenwichMeanSiderealTime(_.end) for _ in table]) gmst_now = lal.GreenwichMeanSiderealTime(gps_time_now) div, rem = divmod(gmst_now - gmsts, 2 * np.pi) i = np.argmin(rem) new_gmst = div[i] * 2 * np.pi + gmsts[i] old_time = table[i].end new_time = lal.LIGOTimeGPS() result = lal.GreenwichMeanSiderealTimeToGPS(new_gmst, new_time) result.disown() del result delta_t = new_time - old_time target_coinc_event_id = int(table[i].coinc_event_id) # Remove unneeded rows table[:] = [ row for row in table if int(row.coinc_event_id) == target_coinc_event_id ] target_end_time = table[0].get_end() coinc_table = table = lsctables.CoincTable.get_table(xmldoc) table[:] = [ row for row in table if int(row.coinc_event_id) == target_coinc_event_id ] table = lsctables.CoincMapTable.get_table(xmldoc) table[:] = [ row for row in table if int(row.coinc_event_id) == target_coinc_event_id ] target_sngl_inspirals = frozenset(row.event_id for row in table) sngl_inspiral_table = table = lsctables.SnglInspiralTable.get_table(xmldoc) table[:] = [row for row in table if row.event_id in target_sngl_inspirals] table = lsctables.ProcessTable.get_table(xmldoc) table[:] = [row for row in table if row.program == 'gstlal_inspiral'] target_process_ids = frozenset(row.process_id for row in table) table = lsctables.SearchSummaryTable.get_table(xmldoc) table[:] = [ row for row in table if target_end_time in row.get_out() and row.process_id in target_process_ids ] target_process_ids = frozenset(row.process_id for row in table) table = lsctables.ProcessTable.get_table(xmldoc) table[:] = [row for row in table if row.process_id in target_process_ids] table = lsctables.ProcessParamsTable.get_table(xmldoc) table[:] = [row for row in table if row.process_id in target_process_ids] # Shift event times for row in coinc_inspiral_table: row.end += delta_t for row in sngl_inspiral_table: row.end += delta_t row.end_time_gmst = lal.GreenwichMeanSiderealTime(row.end) # The old version of gstlal used to produce the "First Two Years" data set # stored likelihood in the coinc_event.likelihood column, but newer # versions store the *natural log* of the likelihood here. The p_astro # calculation requires this to be log likelihood. for row in coinc_table: row.likelihood = np.log(row.likelihood) # Gstlal stores the template's SVD bank index in the Gamma1 column. # Fill this in so that we can calculate p_astro # (see :mod:`gwcelery.tasks.p_astro_gstlal`). for row in sngl_inspiral_table: row.Gamma1 = 16 coinc_xml = io.BytesIO() utils.write_fileobj(xmldoc, coinc_xml) return coinc_xml.getvalue()
epoch = sngl_inspiral.end - (len(snr) - 1) / sample_rate snr = np.concatenate((snr[:0:-1].conj(), snr)) snr *= sngl_inspiral.snr * np.exp(1j * sngl_inspiral.coa_phase) snr_series = lal.CreateCOMPLEX16TimeSeries('snr', epoch, 0, dt, lal.StrainUnit, len(snr)) snr_series.data.data[:] = snr elem = lal.series.build_COMPLEX16TimeSeries(snr_series) elem.appendChild( ligolw_param.Param.from_pyvalue(u'event_id', sngl_inspiral.event_id)) out_xmldoc.childNodes[0].appendChild(elem) # Add CoincMap entry. coinc_map = lsctables.CoincMap() coinc_map.coinc_event_id = coinc.coinc_event_id coinc_map.table_name = sngl_inspiral_table.tableName coinc_map.event_id = sngl_inspiral.event_id coinc_map_table.append(coinc_map) # Record process end time. progress.update(-1, 'writing ' + opts.output.name) ligolw_process.set_process_end_time(process) # Write output file. with ligolw_utils.SignalsTrap(): ligolw_utils.write_fileobj(out_xmldoc, opts.output, gz=(os.path.splitext( opts.output.name)[-1] == ".gz"))
def main(args=None): p = parser() opts = p.parse_args(args) # LIGO-LW XML imports. from glue.ligolw import ligolw from glue.ligolw.param import Param from glue.ligolw.utils import process as ligolw_process from glue.ligolw.utils.search_summary import append_search_summary from glue.ligolw import utils as ligolw_utils from glue.ligolw.lsctables import ( New, CoincDefTable, CoincID, CoincInspiralTable, CoincMapTable, CoincTable, ProcessParamsTable, ProcessTable, SimInspiralTable, SnglInspiralTable, TimeSlideTable) # glue, LAL and pylal imports. from ligo import segments import glue.lal import lal.series import lalsimulation from lalinspiral.inspinjfind import InspiralSCExactCoincDef from lalinspiral.thinca import InspiralCoincDef from tqdm import tqdm # FIXME: disable progress bar monitor thread. # # I was getting error messages that look like this: # # Traceback (most recent call last): # File "/tqdm/_tqdm.py", line 885, in __del__ # self.close() # File "/tqdm/_tqdm.py", line 1090, in close # self._decr_instances(self) # File "/tqdm/_tqdm.py", line 454, in _decr_instances # cls.monitor.exit() # File "/tqdm/_monitor.py", line 52, in exit # self.join() # File "/usr/lib64/python3.6/threading.py", line 1053, in join # raise RuntimeError("cannot join current thread") # RuntimeError: cannot join current thread # # I don't know what causes this... maybe a race condition in tqdm's cleanup # code. Anyway, this should disable the tqdm monitor thread entirely. tqdm.monitor_interval = 0 # BAYESTAR imports. from ..io.events.ligolw import ContentHandler from ..bayestar import filter # Read PSDs. xmldoc, _ = ligolw_utils.load_fileobj( opts.reference_psd, contenthandler=lal.series.PSDContentHandler) psds = lal.series.read_psd_xmldoc(xmldoc, root_name=None) psds = { key: filter.InterpolatedPSD(filter.abscissa(psd), psd.data.data) for key, psd in psds.items() if psd is not None} psds = [psds[ifo] for ifo in opts.detector] # Extract simulation table from injection file. inj_xmldoc, _ = ligolw_utils.load_fileobj( opts.input, contenthandler=ContentHandler) orig_sim_inspiral_table = SimInspiralTable.get_table(inj_xmldoc) # Prune injections that are outside distance limits. orig_sim_inspiral_table[:] = [ row for row in orig_sim_inspiral_table if opts.min_distance <= row.distance <= opts.max_distance] # Open output file. xmldoc = ligolw.Document() xmlroot = xmldoc.appendChild(ligolw.LIGO_LW()) # Create tables. Process and ProcessParams tables are copied from the # injection file. coinc_def_table = xmlroot.appendChild(New(CoincDefTable)) coinc_inspiral_table = xmlroot.appendChild(New(CoincInspiralTable)) coinc_map_table = xmlroot.appendChild(New(CoincMapTable)) coinc_table = xmlroot.appendChild(New(CoincTable)) xmlroot.appendChild(ProcessParamsTable.get_table(inj_xmldoc)) xmlroot.appendChild(ProcessTable.get_table(inj_xmldoc)) sim_inspiral_table = xmlroot.appendChild(New(SimInspiralTable)) sngl_inspiral_table = xmlroot.appendChild(New(SnglInspiralTable)) time_slide_table = xmlroot.appendChild(New(TimeSlideTable)) # Write process metadata to output file. process = register_to_xmldoc( xmldoc, p, opts, ifos=opts.detector, comment="Simulated coincidences") # Add search summary to output file. all_time = segments.segment( [glue.lal.LIGOTimeGPS(0), glue.lal.LIGOTimeGPS(2e9)]) append_search_summary(xmldoc, process, inseg=all_time, outseg=all_time) # Create a time slide entry. Needed for coinc_event rows. time_slide_id = time_slide_table.get_time_slide_id( {ifo: 0 for ifo in opts.detector}, create_new=process) # Populate CoincDef table. inspiral_coinc_def = copy.copy(InspiralCoincDef) inspiral_coinc_def.coinc_def_id = coinc_def_table.get_next_id() coinc_def_table.append(inspiral_coinc_def) found_coinc_def = copy.copy(InspiralSCExactCoincDef) found_coinc_def.coinc_def_id = coinc_def_table.get_next_id() coinc_def_table.append(found_coinc_def) # Precompute values that are common to all simulations. detectors = [lalsimulation.DetectorPrefixToLALDetector(ifo) for ifo in opts.detector] responses = [det.response for det in detectors] locations = [det.location for det in detectors] if opts.jobs == 1: pool_map = map else: from .. import omp from multiprocessing import Pool omp.num_threads = 1 # disable OpenMP parallelism pool_map = Pool(opts.jobs).imap func = functools.partial(simulate, psds=psds, responses=responses, locations=locations, measurement_error=opts.measurement_error, f_low=opts.f_low, waveform=opts.waveform) # Make sure that each thread gets a different random number state. # We start by drawing a random integer s in the main thread, and # then the i'th subprocess will seed itself with the integer i + s. # # The seed must be an unsigned 32-bit integer, so if there are n # threads, then s must be drawn from the interval [0, 2**32 - n). # # Note that *we* are thread 0, so there are a total of # n=1+len(sim_inspiral_table) threads. seed = np.random.randint(0, 2 ** 32 - len(sim_inspiral_table) - 1) np.random.seed(seed) count_coincs = 0 with tqdm(total=len(orig_sim_inspiral_table)) as progress: for sim_inspiral, simulation in zip( orig_sim_inspiral_table, pool_map(func, zip(np.arange(len(orig_sim_inspiral_table)) + seed + 1, orig_sim_inspiral_table))): progress.update() sngl_inspirals = [] used_snr_series = [] net_snr = 0.0 count_triggers = 0 # Loop over individual detectors and create SnglInspiral entries. for ifo, (horizon, abs_snr, arg_snr, toa, series) \ in zip(opts.detector, simulation): if np.random.uniform() > opts.duty_cycle: continue elif abs_snr >= opts.snr_threshold: # If SNR < threshold, then the injection is not found. # Skip it. count_triggers += 1 net_snr += np.square(abs_snr) elif not opts.keep_subthreshold: continue # Create SnglInspiral entry. used_snr_series.append(series) sngl_inspirals.append( sngl_inspiral_table.RowType(**dict( dict.fromkeys(sngl_inspiral_table.validcolumns, None), process_id=process.process_id, ifo=ifo, mass1=sim_inspiral.mass1, mass2=sim_inspiral.mass2, spin1x=sim_inspiral.spin1x, spin1y=sim_inspiral.spin1y, spin1z=sim_inspiral.spin1z, spin2x=sim_inspiral.spin2x, spin2y=sim_inspiral.spin2y, spin2z=sim_inspiral.spin2z, end=toa, snr=abs_snr, coa_phase=arg_snr, eff_distance=horizon / abs_snr))) net_snr = np.sqrt(net_snr) # If too few triggers were found, then skip this event. if count_triggers < opts.min_triggers: continue # If network SNR < threshold, then the injection is not found. # Skip it. if net_snr < opts.net_snr_threshold: continue # Add Coinc table entry. coinc = coinc_table.appendRow( coinc_event_id=coinc_table.get_next_id(), process_id=process.process_id, coinc_def_id=inspiral_coinc_def.coinc_def_id, time_slide_id=time_slide_id, insts=opts.detector, nevents=len(opts.detector), likelihood=None) # Add CoincInspiral table entry. coinc_inspiral_table.appendRow( coinc_event_id=coinc.coinc_event_id, instruments=[ sngl_inspiral.ifo for sngl_inspiral in sngl_inspirals], end=lal.LIGOTimeGPS(1e-9 * np.mean([ sngl_inspiral.end.ns() for sngl_inspiral in sngl_inspirals if sngl_inspiral.end is not None])), mass=sim_inspiral.mass1 + sim_inspiral.mass2, mchirp=sim_inspiral.mchirp, combined_far=0.0, # Not provided false_alarm_rate=0.0, # Not provided minimum_duration=None, # Not provided snr=net_snr) # Record all sngl_inspiral records and associate them with coincs. for sngl_inspiral, series in zip(sngl_inspirals, used_snr_series): # Give this sngl_inspiral record an id and add it to the table. sngl_inspiral.event_id = sngl_inspiral_table.get_next_id() sngl_inspiral_table.append(sngl_inspiral) if opts.enable_snr_series: elem = lal.series.build_COMPLEX8TimeSeries(series) elem.appendChild( Param.from_pyvalue(u'event_id', sngl_inspiral.event_id)) xmlroot.appendChild(elem) # Add CoincMap entry. coinc_map_table.appendRow( coinc_event_id=coinc.coinc_event_id, table_name=sngl_inspiral_table.tableName, event_id=sngl_inspiral.event_id) # Record injection if not opts.preserve_ids: sim_inspiral.simulation_id = sim_inspiral_table.get_next_id() sim_inspiral_table.append(sim_inspiral) count_coincs += 1 progress.set_postfix(saved=count_coincs) # Record coincidence associating injections with events. for i, sim_inspiral in enumerate(sim_inspiral_table): coinc = coinc_table.appendRow( coinc_event_id=coinc_table.get_next_id(), process_id=process.process_id, coinc_def_id=found_coinc_def.coinc_def_id, time_slide_id=time_slide_id, instruments=None, nevents=None, likelihood=None) coinc_map_table.appendRow( coinc_event_id=coinc.coinc_event_id, table_name=sim_inspiral_table.tableName, event_id=sim_inspiral.simulation_id) coinc_map_table.appendRow( coinc_event_id=coinc.coinc_event_id, table_name=coinc_table.tableName, event_id=CoincID(i)) # Record process end time. ligolw_process.set_process_end_time(process) # Write output file. with ligolw_utils.SignalsTrap(): ligolw_utils.write_fileobj( xmldoc, opts.output, gz=(os.path.splitext(opts.output.name)[-1] == ".gz"))
row.__setattr__(d + '_end_time_ns', row.geocent_end_time_ns) row.amp_order = 0 row.coa_phase = 0 row.bandpass = 0 row.taper = inj.taper row.numrel_mode_min = 0 row.numrel_mode_max = 0 row.numrel_data = None row.source = 'ANTANI' row.process_id = 'process:process_id:0' row.simulation_id = 'sim_inspiral:simulation_id:0' sim_table.append(row) inj_file = open("injection.xml","w+") ligolw_utils.write_fileobj(xmldoc, inj_file) injection_set = InjectionSet("injection.xml") sample_rate = 4096 # Hz for det in [Detector(d) for d in ['H1', 'L1', 'V1']]: ts = TimeSeries(numpy.zeros(int(10 * sample_rate)), delta_t=1/sample_rate, epoch=lal.LIGOTimeGPS(end_time - 5), dtype=numpy.float64) injection_set.apply(ts, det.name) max_amp, max_loc = ts.abs_max_loc() pylab.plot(ts,label=det.name) pylab.legend()
subparser.add_argument('ifo1', choices=available_ifos) subparser.add_argument('ifo2', choices=available_ifos) subparser = add_parser(conj) subparser.add_argument('ifos', choices=available_ifos, nargs='+') subparser = add_parser(amplify) subparser.add_argument('ifos', choices=available_ifos, nargs='+') subparser.add_argument('gain', type=float) args = parser.parse_args() kwargs = dict(args.__dict__) func = locals()[kwargs.pop('func')] infile = kwargs.pop('input') outfile = kwargs.pop('output') # Read input file. xmldoc, _ = load_fileobj( infile, contenthandler=LSCTablesAndSeriesContentHandler) # Process it. process = command.register_to_xmldoc(xmldoc, parser, args) func(xmldoc, **kwargs) set_process_end_time(process) # Write output file. with SignalsTrap(): write_fileobj( xmldoc, outfile, gz=(os.path.splitext(outfile.name)[-1] == '.gz'))