def add_events(self, sbtable, inseg=None): """ Add a trial to the current running tally. If segment is provided, then the key in the trial table is set to be this. Otherwise, the segment is determined from the peak times of the snglbursts """ # If no events are provided and no segment is indicated, there is no # operation to map this into a trial, so we do nothing if len(sbtable) == 0 and inseg is None: return if inseg is None: inseg = [] for sb in sbtable: start = sb.start_time + 1e-9 * sb.start_time_ns stop = sb.start_time + sb.duration inseg.append(segments.segment(start, stop)) inseg = segments.segmentlist(inseg).coalesce() inseg = segments.segment(inseg[0][0], inseg[-1][1]) oldsegs = filter(lambda s: s.intersects(inseg), self.onsource.keys()) # FIXME: Is it possible for this to be > 1? # Yes, but the reorganization logic is tricky. # Call normalize often (like everytime you add a new segment). if len(oldsegs) == 1: oldseg = oldsegs[0] sbtable += self.onsource[oldseg] del self.onsource[oldseg] inseg = oldseg | inseg self.onsource[inseg] = sbtable
def do_summary_table(xmldoc, sim_tree, liv_tree): try: search_summary = lsctables.SearchSummaryTable.get_table(xmldoc) except ValueError: search_summary = lsctables.New(lsctables.SearchSummaryTable, [ "process_id", "nevents", "ifos", "comment", "in_start_time", "in_start_time_ns", "out_start_time", "out_start_time_ns", "in_end_time", "in_end_time_ns", "out_end_time", "out_end_time_ns" ]) xmldoc.childNodes[0].appendChild(search_summary) process_id_type = lsctables.ProcessID runids = set() for i in range(0, sim_tree.GetEntries()): sim_tree.GetEntry(i) # Id for the run processed by WaveBurst -> process ID if sim_tree.run in runids: continue row = search_summary.RowType() row.process_id = process_id_type(sim_tree.run) runids.add(sim_tree.run) # Search Summary Table # events found in the run -> nevents setattr(row, "nevents", sim_tree.GetEntries()) # Imstruments involved in the search row.ifos = lsctables.ifos_from_instrument_set( get_ifos_from_index( branch_array_to_list(sim_tree.ifo, sim_tree.ndim))) setattr(row, "comment", "waveburst") # Begin and end time of the segment # TODO: This is a typical offset on either side of the job for artifacts # It can, and probably will change in the future, and should not be hardcoded # TODO: Make this work properly. We need a gps end from the livetime waveoffset = 8 livetime = 600 #live_entries = live_tree.GetEntries() # This is WAAAAAAAAAAAAAY too slow #for l in range(0, live_entries): #liv_tree.GetEntry(l) #livetime = max(livetime, liv_tree.live) #if livetime < 0: #sys.exit("Could not find livetime, cannot fill all of summary table.") # in -- with waveoffset # out -- without waveoffset row.set_in( segments.segment(LIGOTimeGPS(sim_tree.gps - waveoffset), LIGOTimeGPS(sim_tree.gps + livetime + waveoffset))) row.set_out( segments.segment(LIGOTimeGPS(sim_tree.gps), LIGOTimeGPS(sim_tree.gps + livetime))) search_summary.append(row)
def generated_vdb_ascii(json_str,filepath): res_dict=json.loads(json_str) active_list=res_dict['active'] active_segments=segments.segmentlist([segments.segment(x[0],x[1]) for x in active_list]) known_list=res_dict['known'] known_segments=segments.segmentlist([segments.segment(x[0],x[1]) for x in known_list]) query_start=res_dict['query_information']['start'] query_stop=res_dict['query_information']['end'] if query_start!=0 and query_stop!=0: requested_span=segments.segmentlist([segments.segment(query_start,query_stop)]) else: requested_span=segments.segmentlist([segments.segment(0,9999999999)]) active_segments_string=',1 \n'.join([str(i[0])+","+str(i[1]) for i in active_segments])+",1 \n" unknown_segments=requested_span-known_segments unknown_segments_string=',-1 \n'.join([str(i[0])+","+str(i[1]) for i in unknown_segments])+",-1 \n" known_not_active_segments=known_segments-active_segments known_not_active_segments_string=',0 \n'.join([str(i[0])+","+str(i[1]) for i in known_not_active_segments])+",0 \n" output_fileh=open(filepath,'w+') query_info_string=json.dumps(res_dict['query_information'], indent=1) output_fileh.writelines(query_info_string) output_fileh.write('\n') output_fileh.writelines(active_segments_string) output_fileh.writelines(unknown_segments_string) output_fileh.writelines(known_not_active_segments_string) output_fileh.close() return filepath
def generated_vdb_ascii(json_dict,filepath): #res_dict=json.loads(json_str) res_dict=json_dict active_list=res_dict['active'] active_segments=segments.segmentlist([segments.segment(x[0],x[1]) for x in active_list]) active_segments.coalesce() known_list=res_dict['known'] known_segments=segments.segmentlist([segments.segment(x[0],x[1]) for x in known_list]) known_segments.coalesce() query_start=res_dict['query_information']['start'] query_stop=res_dict['query_information']['end'] if query_start!=0 and query_stop!=0: requested_span=segments.segmentlist([segments.segment(query_start,query_stop)]) else: requested_span=segments.segmentlist([segments.segment(0,9999999999)]) active_segments_string=',1 \n'.join([str(i[0])+","+str(i[1]) for i in active_segments])+",1 \n" unknown_segments=requested_span-known_segments unknown_segments_string=',-1 \n'.join([str(i[0])+","+str(i[1]) for i in unknown_segments])+",-1 \n" known_not_active_segments=known_segments-active_segments known_not_active_segments_string=',0 \n'.join([str(i[0])+","+str(i[1]) for i in known_not_active_segments])+",0 \n" output_fileh=open(filepath,'a') query_info_string=json.dumps(res_dict['query_information'], indent=1) output_fileh.writelines(query_info_string) output_fileh.write('\n') output_fileh.writelines(active_segments_string) output_fileh.writelines(unknown_segments_string) output_fileh.writelines(known_not_active_segments_string) output_fileh.close() return filepath
def split_segment(seg, min_segment_length, pad, overlap, short_segment_duration, max_job_length): # avoid infinite loop if min_segment_length + 2 * pad <= overlap: raise ValueError( "infinite loop: min_segment_length + 2 * pad must be > overlap") # clip max_job_length down to an allowed size max_job_length = clip_segment_length(max_job_length, pad, short_segment_duration) seglist = segments.segmentlist() while abs(seg) >= min_segment_length + 2 * pad: # try to use max_job_length each time if abs(seg) >= max_job_length: seglist.append(segments.segment(seg[0], seg[0] + max_job_length)) else: seglist.append( segments.segment( seg[0], seg[0] + clip_segment_length( abs(seg), pad, short_segment_duration))) assert abs(seglist[-1]) != 0 # safety-check for no-op # bounds must be integers if abs((int(seglist[-1][0]) - seglist[-1][0]) / seglist[-1][0]) > 1e-14 or abs( (int(seglist[-1][1]) - seglist[-1][1]) / seglist[-1][1]) > 1e-14: raise ValueError("segment %s does not have integer boundaries" % str(seglist[-1])) # advance segment seg = segments.segment(seglist[-1][1] - overlap, seg[1]) if not seglist: raise ValueError("unable to use segment %s" % str(seg)) return seglist
def normalize(self): """ Redistribute events to offsource and onsource based on current time span. """ all_segs = segments.segmentlist(self.onsource.keys()) if len(all_segs) == 0: return if len(self.offsource.keys()) > 0: all_segs += segments.segmentlist(self.offsource.keys()) all_segs.coalesce() begin, end = all_segs[0][0], all_segs[-1][1] span = float(end - begin) if span < self.onsource_interval: # Not much we can do. return if span > self.offsource_interval + self.onsource_interval: begin = end - (self.offsource_interval + self.onsource_interval) onsource_seg = segments.segment(end - self.onsource_interval, end) offsource_seg = segments.segment(begin, end - self.onsource_interval) for seg, sbt in self.offsource.items(): try: seg & offsource_seg except ValueError: # offsource segment is out of the current window del self.offsource[seg] continue newseg = seg & offsource_seg if seg != newseg: del self.offsource[seg] self.offsource[newseg] = filter( lambda sb: (sb.peak_time + 1e-9 * sb.peak_time_ns) in newseg, sbt) for seg, sbt in self.onsource.items(): if seg in onsource_seg: continue elif offsource_seg.disjoint(seg) == 1: # segment ran off the span since last check del self.onsource[seg] continue offseg = seg & offsource_seg del self.onsource[seg] try: onseg = seg & onsource_seg self.onsource[onseg] = filter( lambda sb: (sb.peak_time + 1e-9 * sb.peak_time_ns) in onseg, sbt) except ValueError: # onsource segment completely out of new segment pass self.offsource[offseg] = filter( lambda sb: (sb.peak_time + 1e-9 * sb.peak_time_ns) in offseg, sbt)
def find_tile_greedy_slew(current_time, current_ra, current_dec, tilesegmentlists, tileprobs, config_struct, tile_struct, keynames, tileAllocatedTime, exptimecheckkeys=[], idle=0): next_obs = -1 idx2 = -1 score_selected = -1 slew_readout_selected = -1 explength_selected = -1 for ii in range(len(tilesegmentlists)): # for every tile key = keynames[ii] # exclude some tiles if keynames[ii] in exptimecheckkeys or np.absolute( tileAllocatedTime[ii]) < 1e-5: continue # calculate slew readout time distance = np.sqrt((tile_struct[key]['ra'] - current_ra)**2 + (tile_struct[key]['dec'] - current_dec)**2) slew_readout = np.max( [config_struct['readout'], distance / config_struct['slew_rate']]) slew_readout = np.max([slew_readout - idle, 0]) slew_readout = slew_readout / 86400 for jj in range(len(tilesegmentlists[ii])): # for every segment seg = tilesegmentlists[ii][jj] if current_time + slew_readout < seg[ 1]: # if ends later than current + slew if current_time + slew_readout >= seg[ 0]: # if starts earlier than current + slew # calculate the score explength = np.min([ seg[1] - current_time - slew_readout, tileAllocatedTime[ii] ]) score = tileprobs[ii] * explength / (1 + slew_readout) if idx2 == -1 or score > score_selected: idx2 = keynames[ii] score_selected = score slew_readout_selected = slew_readout explength_selected = explength elif idx2 == -1: # if starts later than current + slew if next_obs == -1 or next_obs > seg[0]: next_obs = seg[0] break exp_idle_seg = None if idx2 != -1: exp_idle_seg = segments.segment( current_time + slew_readout, current_time + slew_readout + explength_selected) elif next_obs != -1: exp_idle_seg = segments.segment(current_time, next_obs) return idx2, slew_readout_selected, exp_idle_seg
def associate_psds_to_segments(opt, fd_segments, gwstrain, flen, delta_f, flow, dyn_range_factor=1., precision=None): """Generate a set of overlapping PSDs covering the data in GWstrain. Then associate these PSDs with the appropriate segment in strain_segments. Parameters ----------- opt : object Result of parsing the CLI with OptionParser, or any object with the required attributes (psd_model, psd_file, asd_file, psd_estimation, psd_segment_length, psd_segment_stride, psd_inverse_length, psd_output). fd_segments : StrainSegments.fourier_segments() object The fourier transforms of the various analysis segments. The psd attribute of each segment is updated to point to the appropriate PSD. gwstrain : Strain object The timeseries of raw data on which to estimate PSDs. flen : int The length in samples of the output PSDs. delta_f : float The frequency step of the output PSDs. flow: float The low frequncy cutoff to use when calculating the PSD. dyn_range_factor : {1, float} For PSDs taken from models or text files, if `dyn_range_factor` is not None, then the PSD is multiplied by `dyn_range_factor` ** 2. precision : str, choices (None,'single','double') If not specified, or specified as None, the precision of the returned PSD will match the precision of the data, if measuring a PSD, or will match the default precision of the model if using an analytical PSD. If 'single' the PSD will be converted to float32, if not already in that precision. If 'double' the PSD will be converted to float64, if not already in that precision. """ psds_and_times = generate_overlapping_psds(opt, gwstrain, flen, delta_f, flow, dyn_range_factor=dyn_range_factor, precision=precision) for fd_segment in fd_segments: best_psd = None psd_overlap = 0 inp_seg = segments.segment(fd_segment.seg_slice.start, fd_segment.seg_slice.stop) for start_idx, end_idx, psd in psds_and_times: psd_seg = segments.segment(start_idx, end_idx) if psd_seg.intersects(inp_seg): curr_overlap = abs(inp_seg & psd_seg) if curr_overlap > psd_overlap: psd_overlap = curr_overlap best_psd = psd if best_psd is None: err_msg = "No PSDs found intersecting segment!" raise ValueError(err_msg) fd_segment.psd = best_psd
def load_segments_from_xml(xml_doc, return_dict=False, select_id=None): """Read a ligo.segments.segmentlist from the file object file containing an xml segment table. Parameters ---------- xml_doc: name of segment xml file Keyword Arguments: return_dict : [ True | False ] return a ligo.segments.segmentlistdict containing coalesced ligo.segments.segmentlists keyed by seg_def.name for each entry in the contained segment_def_table. Default False select_id : int return a ligo.segments.segmentlist object containing only those segments matching the given segment_def_id integer """ # Load SegmentDefTable and SegmentTable seg_def_table = load_xml_table(xml_doc, glsctables.SegmentDefTable.tableName) seg_table = load_xml_table(xml_doc, glsctables.SegmentTable.tableName) if return_dict: segs = segments.segmentlistdict() else: segs = segments.segmentlist() seg_id = {} for seg_def in seg_def_table: seg_id[int(seg_def.segment_def_id)] = str(seg_def.name) if return_dict: segs[str(seg_def.name)] = segments.segmentlist() for seg in seg_table: if return_dict: segs[seg_id[int(seg.segment_def_id)]]\ .append(segments.segment(seg.start_time, seg.end_time)) continue if select_id and int(seg.segment_def_id) == select_id: segs.append(segments.segment(seg.start_time, seg.end_time)) continue segs.append(segments.segment(seg.start_time, seg.end_time)) if return_dict: for seg_name in seg_id.values(): segs[seg_name] = segs[seg_name].coalesce() else: segs = segs.coalesce() return segs
def do_summary_table(xmldoc, sim_tree, liv_tree): try: search_summary = lsctables.SearchSummaryTable.get_table(xmldoc) except ValueError: search_summary = lsctables.New(lsctables.SearchSummaryTable, ["process_id", "nevents", "ifos", "comment", "in_start_time", "in_start_time_ns", "out_start_time", "out_start_time_ns", "in_end_time", "in_end_time_ns", "out_end_time", "out_end_time_ns"]) xmldoc.childNodes[0].appendChild(search_summary) process_id_type = lsctables.ProcessID runids = set() for i in range(0, sim_tree.GetEntries()) : sim_tree.GetEntry(i) # Id for the run processed by WaveBurst -> process ID if sim_tree.run in runids : continue row = search_summary.RowType() row.process_id = process_id_type(sim_tree.run) runids.add(sim_tree.run) # Search Summary Table # events found in the run -> nevents setattr(row, "nevents", sim_tree.GetEntries()) # Imstruments involved in the search row.ifos = lsctables.ifos_from_instrument_set( get_ifos_from_index( branch_array_to_list ( sim_tree.ifo, sim_tree.ndim ) ) ) setattr(row, "comment", "waveburst") # Begin and end time of the segment # TODO: This is a typical offset on either side of the job for artifacts # It can, and probably will change in the future, and should not be hardcoded # TODO: Make this work properly. We need a gps end from the livetime waveoffset = 8 livetime = 600 #live_entries = live_tree.GetEntries() # This is WAAAAAAAAAAAAAY too slow #for l in range(0, live_entries): #liv_tree.GetEntry(l) #livetime = max(livetime, liv_tree.live) #if livetime < 0: #sys.exit("Could not find livetime, cannot fill all of summary table.") # in -- with waveoffset # out -- without waveoffset row.set_in(segments.segment(LIGOTimeGPS(sim_tree.gps - waveoffset), LIGOTimeGPS(sim_tree.gps + livetime + waveoffset))) row.set_out(segments.segment(LIGOTimeGPS(sim_tree.gps), LIGOTimeGPS(sim_tree.gps + livetime))) search_summary.append(row)
def get_segments(params, config_struct): gpstime = params["gpstime"] event_mjd = Time(gpstime, format='gps', scale='utc').mjd segmentlist = segments.segmentlist() n_windows = len(params["Tobs"]) // 2 start_segments = event_mjd + params["Tobs"][::2] end_segments = event_mjd + params["Tobs"][1::2] for start_segment, end_segment in zip(start_segments, end_segments): segmentlist.append(segments.segment(start_segment, end_segment)) observer = ephem.Observer() observer.lat = str(config_struct["latitude"]) observer.lon = str(config_struct["longitude"]) observer.horizon = str(-12.0) observer.elevation = config_struct["elevation"] date_start = ephem.Date( Time(segmentlist[0][0], format='mjd', scale='utc').iso) date_end = ephem.Date( Time(segmentlist[-1][1], format='mjd', scale='utc').iso) observer.date = ephem.Date( Time(segmentlist[0][0], format='mjd', scale='utc').iso) sun = ephem.Sun() nightsegmentlist = segments.segmentlist() while date_start < date_end: date_rise = observer.next_rising(sun, start=date_start) date_set = observer.next_setting(sun, start=date_start) if date_set > date_rise: date_set = observer.previous_setting(sun, start=date_start) astropy_rise = Time(date_rise.datetime(), scale='utc').mjd astropy_set = Time(date_set.datetime(), scale='utc').mjd segment = segments.segment(astropy_set, astropy_rise) nightsegmentlist = nightsegmentlist + segments.segmentlist([segment]) nightsegmentlist.coalesce() date_start = date_rise observer.date = date_rise segmentlistdic = segments.segmentlistdict() segmentlistdic["observations"] = segmentlist segmentlistdic["night"] = nightsegmentlist segmentlist = segmentlistdic.intersection(["observations", "night"]) segmentlist.coalesce() return segmentlist
def new_plots(instrument, amplitude_func, amplitude_lbl, plots): l = ( FreqVsTime(instrument), HrssVsFreqScatter(instrument, amplitude_func, amplitude_lbl), SimBurstUtils.Efficiency_hrss_vs_freq((instrument,), amplitude_func, amplitude_lbl, 0.1), TriggerCountHistogram(instrument), RecoveredVsInjectedhrss(instrument, amplitude_func, amplitude_lbl), RecoveredPerInjectedhrssVsFreq(instrument, amplitude_func, amplitude_lbl), RecoveredPerInjectedhrssVsBandwidth(instrument, amplitude_func, amplitude_lbl), RecoveredTimeOffset(instrument, segments.segment(-0.03, +0.03), 0.00015), RecoveredFrequencyOffset(instrument, segments.segment(-1.0, +1.0), .002), RecoveredVsInjectedFreq(instrument, amplitude_func) ) return [l[i] for i in plots]
def subdivide(seglist, length, min_length=0): """ Subdivide a segent list into smaller segments of length, allowing for a minimum length (default = 0). """ newlist = [] for seg in seglist: while abs(seg) - min_length > length + min_length: newlist.append(segments.segment(seg[0], seg[0] + length)) seg = segments.segment(seg[0] + length, seg[1]) if abs(seg) > 0: newlist.append(segments.segment(seg[0], seg[1] - min_length)) newlist.append(segments.segment(seg[1] - min_length, seg[1])) return segments.segmentlist(newlist)
def construct_trials(seg_files, seg_dict, ifos, slide_dict, vetoes): """Constructs trials from triggers, timeslides, segments and vetoes""" trial_dict = {} # Get segments segs = read_seg_files(seg_files) # Separate segments trial_time = abs(segs['on']) for slide_id in slide_dict: # These can only *reduce* the analysis time curr_seg_list = seg_dict[slide_id] # Construct the buffer segment list seg_buffer = segments.segmentlist() for ifo in ifos: slide_offset = slide_dict[slide_id][ifo] seg_buffer.append( segments.segment(segs['buffer'][0] - slide_offset, segs['buffer'][1] - slide_offset)) seg_buffer.coalesce() # Construct the ifo-indexed dictionary of slid veteoes slid_vetoes = slide_vetoes(vetoes, slide_dict, slide_id) # Construct trial list and check against buffer trial_dict[slide_id] = segments.segmentlist() for curr_seg in curr_seg_list: iter_int = 1 while 1: trial_end = curr_seg[0] + trial_time * iter_int if trial_end > curr_seg[1]: break curr_trial = segments.segment(trial_end - trial_time, trial_end) if not seg_buffer.intersects_segment(curr_trial): intersect = numpy.any([ slid_vetoes[ifo].intersects_segment(curr_trial) for ifo in ifos ]) if not intersect: trial_dict[slide_id].append(curr_trial) iter_int += 1 return trial_dict
def create_node(self, trig_files, bank_file, stat_files, veto_file, veto_name, template_str, pivot_ifo, fixed_ifo, tags=None): if tags is None: tags = [] segs = trig_files.get_times_covered_by_files() seg = segments.segment(segs[0][0], segs[-1][1]) node = Node(self) node.add_input_opt('--template-bank', bank_file) node.add_input_list_opt('--trigger-files', trig_files) if len(stat_files) > 0: node.add_input_list_opt('--statistic-files', stat_files) if veto_file is not None: node.add_input_opt('--veto-files', veto_file) node.add_opt('--segment-name', veto_name) node.add_opt('--pivot-ifo', pivot_ifo) node.add_opt('--fixed-ifo', fixed_ifo) node.add_opt('--template-fraction-range', template_str) node.new_output_file_opt(seg, '.hdf', '--output-file', tags=tags) return node
def from_T050017(cls, url, coltype = LIGOTimeGPS): """ Parse a URL in the style of T050017-00 into a CacheEntry. The T050017-00 file name format is, essentially, observatory-description-start-duration.extension Example: >>> c = CacheEntry.from_T050017("file://localhost/data/node144/frames/S5/strain-L2/LLO/L-L1_RDS_C03_L2-8365/L-L1_RDS_C03_L2-836562330-83.gwf") >>> c.observatory 'L' >>> c.host 'localhost' >>> os.path.basename(c.path) 'L-L1_RDS_C03_L2-836562330-83.gwf' """ match = cls._url_regex.search(url) if not match: raise ValueError("could not convert %s to CacheEntry" % repr(url)) observatory = match.group("obs") description = match.group("dsc") # FIXME: remove typecasts when LIGOTimeGPS can be passed a unicode start = str(match.group("strt")) duration = str(match.group("dur")) if start == "-" and duration == "-": # no segment information segment = None else: segment = segments.segment(coltype(start), coltype(start) + coltype(duration)) return cls(observatory, description, segment, url)
def get_summary(basedir, ifo, cluster, cat, start_time, end_time): all_sum = segmentlist([]) cur_time = start_time while cur_time < end_time: tstring = os.popen('tconvert -f %Y%m/%Y%m%d ' + str(cur_time)).readlines()[0].strip() infile = open('%s/%s/%s-0-SUMMARY_%s.csv' % (basedir, tstring, ifo, cluster)) lines = [l.strip().split(',') for l in infile.readlines()] summary = segmentlist([segment(int(l[0]), int(l[1])) for l in lines]).coalesce() all_sum = all_sum + summary cur_time += 60 * 60 * 24 all_sum = all_sum & segmentlist([segment(start_time, end_time)]) return all_sum
def create_node(self, zerolag, full_data, injfull, fullinj, ifos, tags=None): if tags is None: tags = [] segs = zerolag.get_times_covered_by_files() seg = segments.segment(segs[0][0], segs[-1][1]) node = Node(self) node.add_input_list_opt('--zero-lag-coincs', zerolag) if isinstance(full_data, list): node.add_input_list_opt('--full-data-background', full_data) else: node.add_input_opt('--full-data-background', full_data) node.add_input_list_opt('--mixed-coincs-inj-full', injfull) node.add_input_list_opt('--mixed-coincs-full-inj', fullinj) node.add_opt('--ifos', ifos) node.new_output_file_opt(seg, '.hdf', '--output-file', tags=tags) return node
def convert_json_list_to_segmentlist(jsonlist): """ Helper function used to convert json list of lists type object to a segmentlist object """ segment_list=segments.segmentlist([segments.segment(x[0],x[1]) for x in jsonlist]) return segment_list
def get_output(self): if self._AnalysisNode__output is None: if None in (self.get_start(), self.get_end(), self.get_ifo(), self.__usertag): raise ValueError("start time, end time, ifo, or user tag has not been set") seg = segments.segment(lal.LIGOTimeGPS(self.get_start()), lal.LIGOTimeGPS(self.get_end())) self.set_output(os.path.join(self.output_dir, "%s-POWER_%s-%d-%d.xml.gz" % (self.get_ifo(), self.__usertag, int(self.get_start()), int(self.get_end()) - int(self.get_start())))) return self._AnalysisNode__output
def get_output(self): if self._AnalysisNode__output is None: if None in (self.get_start(), self.get_end(), self.get_ifo(), self.__usertag): raise ValueError("start time, end time, ifo, or user tag has not been set") seg = segments.segment(lal.LIGOTimeGPS(self.get_start()), lal.LIGOTimeGPS(self.get_end())) self.set_output(os.path.join(self.output_dir, "%s-POWER_%s-%d-%d.xml.gz" % (self.get_ifo(), self.__usertag, int(self.get_start()), int(self.get_end()) - int(self.get_start())))) return self._AnalysisNode__output
def process_row(self, channel, rate, bin_idx, buftime, row): """ Given a channel, rate, and the current buffer time, will process a row from a gstreamer buffer. """ # if segments provided, ensure that trigger falls within these segments if self.frame_segments[self.instrument]: trigger_seg = segments.segment( LIGOTimeGPS(row.end_time, row.end_time_ns), LIGOTimeGPS(row.end_time, row.end_time_ns)) if not self.frame_segments[self.instrument] or self.frame_segments[ self.instrument].intersects_segment(trigger_seg): waveform = self.waveforms[channel].index_to_waveform( rate, bin_idx, row.channel_index) trigger_time = row.end_time + row.end_time_ns * 1e-9 # append row for data transfer/saving channel_name = self.bin_to_channel(channel, bin_idx) feature_row = { 'timestamp': utils.floor_div(buftime, 1. / self.sample_rate), 'channel': channel_name, 'snr': row.snr, 'phase': row.phase, 'time': trigger_time, 'frequency': waveform['frequency'], 'q': waveform['q'], 'duration': waveform['duration'], } timestamp = utils.floor_div(buftime, self.buffer_size) self.feature_queue.append(timestamp, channel_name, feature_row)
def get_exposures(params, config_struct, segmentlist): ''' Convert the availability times to a list segments with the length of telescope exposures. segmentlist: the segments that the telescope can do the follow-up. ''' exposurelist = segments.segmentlist() if "overhead_per_exposure" in config_struct.keys(): overhead = config_struct["overhead_per_exposure"] else: overhead = 0.0 # add the filter change time to the total overheads for integrated if not params["doAlternatingFilters"]: overhead = overhead + config_struct["filt_change_time"] exposure_time = np.max(params["exposuretimes"]) for ii in range(len(segmentlist)): start_segment, end_segment = segmentlist[ii][0], segmentlist[ii][1] exposures = np.arange(start_segment, end_segment, (overhead + exposure_time) / 86400.0) for jj in range(len(exposures)): exposurelist.append( segments.segment(exposures[jj], exposures[jj] + exposure_time / 86400.0)) return exposurelist
def new_plots(plots): deltat_seg = segments.segment(-0.3, +0.3) deltat_width = 0.03125 l = [ RateContours("H2", "H1"), ConfidenceContours("H2", "H1", magnitude_a, "Confidence", 1, 10**10), ConfidenceContours("H2", "L1", magnitude_a, "Confidence", 1, 10**10), ConfidenceContours("L1", "H1", magnitude_a, "Confidence", 1, 10**10), ConfidenceContours("H2", "H1", magnitude_b, r"Power / D.o.F. / ($F_{+}^{2} + F_{\times}^{2}$)", 1, 10**10), ConfidenceContours("H2", "L1", magnitude_b, r"Power / D.o.F. / ($F_{+}^{2} + F_{\times}^{2}$)", 1, 10**10), ConfidenceContours("L1", "H1", magnitude_b, r"Power / D.o.F. / ($F_{+}^{2} + F_{\times}^{2}$)", 1, 10**10), ConfidenceContourProjection( numpy.array((-1 / math.sqrt(2), +1 / math.sqrt(2), 0), "Float64"), numpy.array( (-1 / math.sqrt(4), -1 / math.sqrt(4), +1 / math.sqrt(2)), "Float64"), magnitude_b, 10**5), RateVsConfidence("H1"), RateVsConfidence("H2"), RateVsConfidence("L1") ] return [l[i] for i in plots]
def convert_json_list_to_segmentlist(jsonlist): """ Helper function used to convert json list of lists type object to a segmentlist object """ segment_list=segments.segmentlist([segments.segment(x[0],x[1]) for x in jsonlist]) return segment_list
def from_T050017(cls, url, coltype = LIGOTimeGPS): """ Parse a URL in the style of T050017-00 into a CacheEntry. The T050017-00 file name format is, essentially, observatory-description-start-duration.extension Example: >>> c = CacheEntry.from_T050017("file://localhost/data/node144/frames/S5/strain-L2/LLO/L-L1_RDS_C03_L2-8365/L-L1_RDS_C03_L2-836562330-83.gwf") >>> c.observatory 'L' >>> c.host 'localhost' >>> os.path.basename(c.path) 'L-L1_RDS_C03_L2-836562330-83.gwf' """ match = cls._url_regex.search(url) if not match: raise ValueError("could not convert %s to CacheEntry" % repr(url)) observatory = match.group("obs") description = match.group("dsc") # FIXME: remove typecasts when LIGOTimeGPS can be passed a unicode start = str(match.group("strt")) duration = str(match.group("dur")) if start == "-" and duration == "-": # no segment information segment = None else: segment = segments.segment(coltype(start), coltype(start) + coltype(duration)) return cls(observatory, description, segment, url)
def compute_segment_lists(seglists, offset_vectors, min_segment_length, pad): # don't modify original seglists = seglists.copy() # ignore offset vectors referencing instruments we don't have offset_vectors = [offset_vector for offset_vector in offset_vectors if set(offset_vector.keys()).issubset(set(seglists.keys()))] # cull too-short single-instrument segments from the input # segmentlist dictionary; this can significantly increase # the speed of the get_coincident_segmentlistdict() # function when the input segmentlists have had many data # quality holes poked out of them remove_too_short_segments(seglists, min_segment_length, pad) # extract the segments that are coincident under the time # slides new = cafe.get_coincident_segmentlistdict(seglists, offset_vectors) # round to integer boundaries because lalapps_StringSearch can't accept # non-integer start/stop times # FIXME: fix that in lalapps_StringSearch for seglist in new.values(): for i in range(len(seglist)): seglist[i] = segments.segment(int(math.floor(seglist[i][0])), int(math.ceil(seglist[i][1]))) # intersect with original segments to ensure we haven't expanded beyond # original bounds new &= seglists # again remove too-short segments remove_too_short_segments(new, min_segment_length, pad) # done return new
def get_ha_segments(config_struct,segmentlist,observer,fxdbdy,radec): if "ha_constraint" in config_struct: ha_constraint = config_struct["ha_constraint"].split(",") ha_min = float(ha_constraint[0]) ha_max = float(ha_constraint[1]) else: ha_min, ha_max = -24.0, 24.0 if config_struct["telescope"] == "DECam": if radec.dec.deg <= -30.0: ha_min, ha_max = -5.2, 5.2 else: ha_min, ha_max = -0.644981*np.sqrt(35.0-radec.dec.deg), 0.644981*np.sqrt(35.0-radec.dec.deg) location = astropy.coordinates.EarthLocation(config_struct["longitude"], config_struct["latitude"], config_struct["elevation"]) halist = segments.segmentlist() for seg in segmentlist: mjds = np.linspace(seg[0], seg[1], 100) tt = Time(mjds, format='mjd', scale='utc', location=location) lst = tt.sidereal_time('mean') ha = (lst - radec.ra).hour idx = np.where((ha >= ha_min) & (ha <= ha_max))[0] if len(idx) >= 2: halist.append(segments.segment(mjds[idx[0]],mjds[idx[-1]])) return halist
def filename_metadata(filename): """Return metadata parsed from a filename following LIGO-T050017 Parameters ---------- filename : `str` the path name of a file Returns ------- obs : `str` the observatory metadata tag : `str` the file tag segment : `ligo.segments.segment` the GPS ``[start, stop)`` interval for this file Notes ----- `LIGO-T050017 <https://dcc.ligo.org/LIGO-T050017>`__ declares a file naming convention that includes documenting the GPS start integer and integer duration of a file, see that document for more details. """ obs, desc, start, end = os.path.basename(filename).split('-') start = int(start) end = int(end.split('.')[0]) return obs, desc, segment(start, start + end)
def kwargs_from_triggers(self, events, offsetvector): assert len(events) >= self.min_instruments # # pick a random, but reproducible, trigger to provide a # reference timestamp for, e.g, the \Delta t's between # instruments and the time spanned by the candidate. # # the trigger times are conveyed as offsets-from-epoch. # the trigger times are taken to be their time-shifted # values, the time-shifted reference trigger is used to # define the epoch. the objective here is to allow the # trigger times to be converted to floats without loss of # precision, without loosing knowledge of the \Delta t's # between triggers, and in such a way that singles always # have a time-shifted offset-from-epoch of 0. # # for the time spanned by the event, we need a segment for # every instrument whether or not it provided a trigger, # and reflecting the offset vector that was considered when # this candidate was formed (the ranking statistic needs to # know when it was we were looking for triggers in the # instruments that failed to provide them). for # instruments that do not provide a trigger, we time-shift # the reference trigger's interval under the assumption # that because we use exact-match coincidence the interval # is the same for all instruments. # reference = min(events, key = lambda event: event.ifo) ref_start, ref_offset = reference.start_time, offsetvector[reference.ifo] # segment spanned by reference event seg = segments.segment(ref_start, ref_start + reference.duration) # initially populate segs dictionary shifting reference # instrument's segment according to offset vectors segs = dict((instrument, seg.shift(ref_offset - offsetvector[instrument])) for instrument in self.instruments) # for any any real triggers we have, use their true # intervals segs.update((event.ifo, segments.segment(event.start_time, event.start_time+event.duration)) for event in events) return dict( segments = segs, snr2s = dict((event.ifo, event.snr**2.) for event in events), chi2s_over_snr2s = dict((event.ifo, event.chisq / event.chisq_dof / event.snr**2.) for event in events), durations = dict((event.ifo, event.duration) for event in events) )
def new_plots(instrument, amplitude_func, amplitude_lbl, plots): l = (FreqVsTime(instrument), HrssVsFreqScatter(instrument, amplitude_func, amplitude_lbl), SimBurstUtils.Efficiency_hrss_vs_freq( (instrument, ), amplitude_func, amplitude_lbl, 0.1), TriggerCountHistogram(instrument), RecoveredVsInjectedhrss(instrument, amplitude_func, amplitude_lbl), RecoveredPerInjectedhrssVsFreq(instrument, amplitude_func, amplitude_lbl), RecoveredPerInjectedhrssVsBandwidth(instrument, amplitude_func, amplitude_lbl), RecoveredTimeOffset(instrument, segments.segment(-0.03, +0.03), 0.00015), RecoveredFrequencyOffset(instrument, segments.segment(-1.0, +1.0), .002), RecoveredVsInjectedFreq(instrument, amplitude_func)) return [l[i] for i in plots]
def ExcessPowerNearCoincCompare(sim, burst, offsetvector): """ Return False (injection matches coinc) if the peak time of the sim is "near" the burst event. """ tinj = sim.time_at_instrument(burst.ifo, offsetvector) window = SimBurstUtils.burst_is_near_injection_window return segments.segment(tinj - window, tinj + window).disjoint(burst.period)
def __init__(self, ifo, width, max): self.fig, self.axes = SnglBurstUtils.make_burst_plot("Delay (s)", "Count / Delay") self.ifo = ifo self.nevents = 0 # 21 bins per filter width interval = segments.segment(0, max + 2) self.bins = rate.BinnedDensity(rate.NDBins((rate.LinearBins(interval[0], interval[1], int(float(abs(interval)) / width) * 21),))) self.axes.semilogy()
def segmentlistdict_unnormalize(seglistdict, origin): """ The opposite of segmentlistdict_normalize(), restores the times in a segmentlist dictionary to absolute times. The modification is done in place. """ for seglist in seglistdict.itervalues(): seglist[:] = (segments.segment(origin + seg[0], origin + seg[1]) for seg in seglist)
def finish(self): self.axes.plot(self.injected_x, self.injected_y, "k+") if not options.made_only: self.axes.plot(self.missed_x, self.missed_y, "rx") for seg in ~self.seglist & segments.segmentlist([segments.segment(self.axes.get_xlim())]): self.axes.axvspan(float(seg[0]), float(seg[1]), facecolor = "k", alpha = 0.2) self.axes.set_ylim([min(self.injected_y), max(self.injected_y)]) self.axes.set_title("Injection Locations\n(%d Injections)" % self.num_injections)
def convert_json_list_to_segmentlist(jsonlist): """ Helper function used to convert JSON list of lists-type object to a segmentlist object- * Utility method, ripped from jsonhelper.py in dqsegdb package, until we can use it as a dependency. """ return segments.segmentlist([segments.segment(x[0],x[1]) for x in jsonlist])
def ExcessPowerNearCoincCompare(sim, burst, offsetvector): """ Return False (injection matches coinc) if the peak time of the sim is "near" the burst event. """ tinj = sim.time_at_instrument(burst.ifo, offsetvector) window = SimBurstUtils.burst_is_near_injection_window return segments.segment(tinj - window, tinj + window).disjoint(burst.period)
def __init__(self, ifo, width, max): self.fig, self.axes = SnglBurstUtils.make_burst_plot("Delay (s)", "Count / Delay") self.ifo = ifo self.nevents = 0 # 21 bins per filter width interval = segments.segment(0, max + 2) self.bins = rate.BinnedDensity(rate.NDBins((rate.LinearBins(interval[0], interval[1], int(float(abs(interval)) / width) * 21),))) self.axes.semilogy()
def sngl_burst_is_vetoed(ifo, start, start_ns, duration, veto_segs=veto_segs): start = dbtables.lsctables.LIGOTimeGPS(start, start_ns) return ifo in veto_segs and veto_segs[ifo].intersects_segment( segments.segment(start, start + duration))
def segmentlistdict_normalize(seglistdict, origin): """ Convert the times in a segmentlist dictionary to floats relative to origin. The purpose is to allow segment lists stored as LIGOTimeGPS times to be manipulated more quickly without loss of precision. The modification is done in place. """ for seglist in seglistdict.itervalues(): seglist[:] = (segments.segment(float(seg[0] - origin), float(seg[1] - origin)) for seg in seglist)
def generated_ascii(json_str,filepath): res_dict=json.loads(json_str) active_list=res_dict['active'] active_segments=segments.segmentlist([segments.segment(x[0],x[1]) for x in active_list]) active_segments_string='\n'.join([str(i[0])+","+str(i[1]) for i in active_segments]) output_fileh=open(filepath,'w+') output_fileh.writelines(active_segments_string) output_fileh.close() return filepath
def finish(self): self.axes.set_title("Time-Frequency Plane\n(%d Triggers)" % self.nevents) for seg in ~self.seglist & segments.segmentlist( [segments.segment(self.axes.get_xlim())]): self.axes.axvspan(float(seg[0]), float(seg[1]), facecolor="k", alpha=0.2)
def get_output_cache(self): """ Returns a LAL cache of the output file name. Calling this method also induces the output name to get set, so it must be at least once. """ if not self.output_cache: self.output_cache = [CacheEntry(self.get_ifo(), self.__usertag, segments.segment(lal.LIGOTimeGPS(self.get_start()), lal.LIGOTimeGPS(self.get_end())), "file://localhost" + os.path.abspath(self.get_output()))] return self.output_cache
def get_output_cache(self): """ Returns a LAL cache of the output file name. Calling this method also induces the output name to get set, so it must be at least once. """ if not self.output_cache: # FIXME: instruments hardcoded to "everything" self.output_cache = [CacheEntry(u"G1+H1+H2+L1+T1+V1", self.__usertag, segments.segment(lal.LIGOTimeGPS(self.get_start()), lal.LIGOTimeGPS(self.get_end())), "file://localhost" + os.path.abspath(self.get_output()))] return self.output_cache
def StringCuspSnglCompare(sim, burst, offsetvector): """ Return False (injection matches event) if an autocorrelation-width window centred on the injection is continuous with the time interval of the burst. """ tinj = sim.time_at_instrument(burst.ifo, offsetvector) window = SimBurstUtils.stringcusp_autocorrelation_width / 2 # uncomment last part of expression to impose an amplitude cut return segments.segment(tinj - window, tinj + window).disjoint(burst.period) #or abs(sim.amplitude / SimBurstUtils.string_amplitude_in_instrument(sim, burst.ifo, offsetvector)) > 3
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 : ligo.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 new_plots(ifo, plots): l = ( RateVsPeakFreq(ifo, segments.segment(options.frequency_range), 4), Durations(ifo), Delays(ifo, 0.25, 20), RateVsSNR(ifo), RateVsConfidence(ifo), ConfidenceVsTime(ifo), ConfidenceVsFrequencyScatter(ifo), TimeFrequencyPlane(ifo) ) return [l[i] for i in plots]
def get_output(self): """ Returns the file name of output from the ring code. This must be kept synchronized with the name of the output file in ring.c. """ if self._AnalysisNode__output is None: if None in (self.get_start(), self.get_end(), self.get_ifo(), self.__usertag): raise ValueError("start time, end time, ifo, or user tag has not been set") seg = segments.segment(LIGOTimeGPS(self.get_start()), LIGOTimeGPS(self.get_end())) self.set_output(os.path.join(self.output_dir, "%s-STRINGSEARCH_%s-%d-%d.xml.gz" % (self.get_ifo(), self.__usertag, int(self.get_start()), int(self.get_end()) - int(self.get_start())))) return self._AnalysisNode__output
def coalesceResultDictionary(result_dict): """ Takes a dictionary as returned by QueryTimes or QueryTimeless and converts the lists of tuples into actual segment lists (and coalesces them). Parameters ---------- result_dict : `dict` This is the input result dictionary from the other api calls out_result_dict : `dict` This is the output result dictionary with actual segment lists (and coalesced results). """ import copy out_result_dict=copy.deepcopy(result_dict) active_seg_python_list=[segments.segment(i[0],i[1]) for i in result_dict['active']] active_seg_list=segments.segmentlist(active_seg_python_list) active_seg_list.coalesce() out_result_dict['active']=active_seg_list known_seg_python_list=[segments.segment(i[0],i[1]) for i in result_dict['known']] known_seg_list=segments.segmentlist(known_seg_python_list) known_seg_list.coalesce() out_result_dict['known']=known_seg_list return out_result_dict
def split_segment(timing_params, segment, psds_per_job): """ Split the data segment into correctly-overlaping segments. We try to have the numbers of PSDs in each segment be equal to psds_per_job, but with a short segment at the end if needed. """ # in seconds joblength = job_length_from_psds(timing_params, psds_per_job) # in samples joboverlap = 2 * timing_params.filter_corruption + (timing_params.psd_length - timing_params.psd_shift) # in seconds joboverlap /= timing_params.resample_rate segs = segments.segmentlist() t = segment[0] while t + joblength <= segment[1]: segs.append(segments.segment(t, t + joblength) & segment) t += joblength - joboverlap extra_psds = int(psds_from_job_length(timing_params, float(segment[1] - t))) if extra_psds: segs.append(segments.segment(t, t + job_length_from_psds(timing_params, extra_psds))) return segs
def split_segment(seg, min_segment_length, pad, overlap, short_segment_duration, max_job_length): # avoid infinite loop if min_segment_length + 2 * pad <= overlap: raise ValueError("infinite loop: min_segment_length + 2 * pad must be > overlap") # clip max_job_length down to an allowed size max_job_length = clip_segment_length(max_job_length, pad, short_segment_duration) seglist = segments.segmentlist() while abs(seg) >= min_segment_length + 2 * pad: # try to use max_job_length each time if abs(seg) >= max_job_length: seglist.append(segments.segment(seg[0], seg[0] + max_job_length)) else: seglist.append(segments.segment(seg[0], seg[0] + clip_segment_length(abs(seg), pad, short_segment_duration))) assert abs(seglist[-1]) != 0 # safety-check for no-op # bounds must be integers if abs((int(seglist[-1][0]) - seglist[-1][0]) / seglist[-1][0]) > 1e-14 or abs((int(seglist[-1][1]) - seglist[-1][1]) / seglist[-1][1]) > 1e-14: raise ValueError("segment %s does not have integer boundaries" % str(seglist[-1])) # advance segment seg = segments.segment(seglist[-1][1] - overlap, seg[1]) if not seglist: raise ValueError("unable to use segment %s" % str(seg)) return seglist
def get_valid_segments(segment_url, base_dir, ifo, science_flag, start_time, end_time): print("Finding valid analysis times for %s, please hold..." % ifo) cmd = 'ligolw_segment_query --query-segments --segment-url %s --include-segments %s --gps-start-time %d --gps-end-time %d | ligolw_print -t segment -c start_time -c end_time' % (segment_url, science_flag, start_time, end_time) pipe = os.popen(cmd) print(cmd) results = [x.strip().split(',') for x in pipe] science = segments.segmentlist([segments.segment(int(x[0]), int(x[1])) for x in results]) science.coalesce() print("Science: ") for s in science: print(s[0], s[1]) framedir = base_dir + '/' + ifo[0] + '1' chunks = [f.split('.')[0].split('-') for f in get_all_files_in_range(framedir, start_time, end_time)] available = segments.segmentlist([ segments.segment( int(x[-2]), int(x[-2]) + int(x[-1]) ) for x in chunks if len(x) == 6 ]) available.coalesce() print("Available:") for s in available: print(s[0], s[1]) result = science & available result.coalesce() print("Result:") for s in result: print(s[0], s[1]) print("done.") return result
def new_plots(plots): deltat_seg = segments.segment(-0.3, +0.3) deltat_width = 0.03125 l = [ RateContours("H2", "H1"), ConfidenceContours("H2", "H1", magnitude_a, "Confidence", 1, 10**10), ConfidenceContours("H2", "L1", magnitude_a, "Confidence", 1, 10**10), ConfidenceContours("L1", "H1", magnitude_a, "Confidence", 1, 10**10), ConfidenceContours("H2", "H1", magnitude_b, r"Power / D.o.F. / ($F_{+}^{2} + F_{\times}^{2}$)", 1, 10**10), ConfidenceContours("H2", "L1", magnitude_b, r"Power / D.o.F. / ($F_{+}^{2} + F_{\times}^{2}$)", 1, 10**10), ConfidenceContours("L1", "H1", magnitude_b, r"Power / D.o.F. / ($F_{+}^{2} + F_{\times}^{2}$)", 1, 10**10), ConfidenceContourProjection(numpy.array((-1/math.sqrt(2), +1/math.sqrt(2), 0), "Float64"), numpy.array((-1/math.sqrt(4), -1/math.sqrt(4), +1/math.sqrt(2)), "Float64"), magnitude_b, 10**5), RateVsConfidence("H1"), RateVsConfidence("H2"), RateVsConfidence("L1") ] return [l[i] for i in plots]
def columns_from_file_list(file_list, columns, ifo, start, end): """ Return columns of information stored in single detector trigger files. Parameters ---------- file_list_file : string pickle file containing the list of single detector triggers. ifo : string The ifo to return triggers for. columns : list of strings The list of columns to read from the trigger files. start : int The start time to get triggers from end : int The end time to get triggers from Returns ------- trigger_dict : dict A dictionary of column vectors with column names as keys. """ file_list = file_list.find_output_with_ifo(ifo) file_list = file_list.find_all_output_in_range(ifo, segment(start, end)) trig_dict = {} for trig_file in file_list: f = h5py.File(trig_file.storage_path, 'r') time = f['end_time'][:] pick = numpy.logical_and(time < end, time > start) pick_loc = numpy.where(pick)[0] for col in columns: if col not in trig_dict: trig_dict[col] = [] trig_dict[col] = numpy.concatenate([trig_dict[col], f[col][:][pick_loc]]) return trig_dict
def get_sngl_burst_row(sngl_burst_table, sim_tree, d): row = sngl_burst_table.RowType() setattr(row, "search", "waveburst") # Interferometer name -> ifo setattr(row, "ifo", get_ifos_from_index(sim_tree.ifo[d]) ) # Timing peak = LIGOTimeGPS(sim_tree.time[d]) seg = segments.segment(LIGOTimeGPS(sim_tree.start[d]), LIGOTimeGPS(sim_tree.stop[d])) # Central time in the detector -> cent_time row.set_peak(peak) # Start time in the detector -> end_time row.set_start(seg[0]) # Stop time in the detector -> star_time row.set_stop(seg[1]) # Event duration row.duration = abs(seg) # TODO: Make sure this is right = Time lag used to shift detector -> lag setattr(row, "time_lag", sim_tree.lag[d]) # Frequency # Central frequency in the detector -> frequency setattr(row, "peak_frequency", sim_tree.frequency[d]) # Low frequency of the event in the detector -> flow setattr(row, "flow", sim_tree.low[d]) # High frequency of the event in the detector -> fhigh setattr(row, "fhigh", sim_tree.high[d]) # Bandwidth setattr(row, "bandwidth", sim_tree.bandwidth[d]) # Shape # number of pizels on the TF plane -> tfsize setattr(row, "tfvolume", sim_tree.size[d]) # Energy # energy / noise variance -> snr setattr(row, "snr", sim_tree.snr[d]) # TODO: What to do with this? GW strain #setattr(row, "strain", sim_tree.strain[d]) # h _ root square sum setattr(row, "hrss", sim_tree.hrss[d]) return row
def run_show_types(doc, connection, engine, gps_start_time, gps_end_time, included_segments_string, excluded_segments_string): resulttable = lsctables.New(ShowTypesResultTable) doc.childNodes[0].appendChild(resulttable) sql = """SELECT segment_definer.ifos, segment_definer.name, segment_definer.version, (CASE WHEN segment_definer.comment IS NULL THEN '-' WHEN segment_definer.comment IS NOT NULL THEN segment_definer.comment END), segment_summary.start_time, segment_summary.end_time, (CASE WHEN segment_summary.comment IS NULL THEN '-' WHEN segment_summary.comment IS NOT NULL THEN segment_summary.comment END) FROM segment_definer, segment_summary WHERE segment_definer.segment_def_id = segment_summary.segment_def_id AND NOT (segment_summary.start_time > %d OR %d > segment_summary.end_time) """ % (gps_end_time, gps_start_time) rows = engine.query(sql) seg_dict = {} for row in rows: ifos, name, version, segment_definer_comment, segment_summary_start_time, segment_summary_end_time, segment_summary_comment = row key = (ifos, name, version, segment_definer_comment, segment_summary_comment) if key not in seg_dict: seg_dict[key] = [] seg_dict[key].append(segments.segment(segment_summary_start_time, segment_summary_end_time)) for key, value in seg_dict.iteritems(): segmentlist = segments.segmentlist(value) segmentlist.coalesce() for segment in segmentlist: result = ShowTypesResult() result.ifos, result.name, result.version, result.segment_definer_comment, result.segment_summary_comment = key result.segment_summary_start_time, result.segment_summary_end_time = segment result.ifos = result.ifos.strip() resulttable.append(result) engine.close()
if offSourceSegment is None: print("Warning: insufficient multi-IFO data to construct an off-source segment for GRB %s; skipping" % grb.event_number_grb, file=sys.stderr) continue elif opts.verbose: print("Sufficient off-source data has been found in", ifo_times, "time.") # write out the segment list to a segwizard file offsource_segfile = idirectory + "/offSourceSeg.txt" segmentsUtils.tosegwizard(open(offsource_segfile, "w"), segments.segmentlist([offSourceSegment])) onsource_segfile = idirectory + "/onSourceSeg.txt" segmentsUtils.tosegwizard(file(onsource_segfile, "w"), segments.segmentlist([onSourceSegment])) segLen = abs( onSourceSegment ) bufferSegment = segments.segment( onSourceSegment[0]-opts.number_buffer_left*segLen,\ onSourceSegment[1]+opts.number_buffer_right*segLen) buffer_segfile = idirectory + "/bufferSeg.txt" segmentsUtils.tosegwizard(file(buffer_segfile, "w"), segments.segmentlist([bufferSegment])) if opts.verbose: print("on-source segment: ", onSourceSegment) print("off-source segment: ", offSourceSegment) ############################################################################ # set up the analysis dag for this interval # # In doing this, we simply drop the configuration file into the # sub-directory, modify as needed, and then run the appropriate DAG # generation script. In slightly more detail, steps are: #