def get_data(query: str): grace_client = GraceDb() events = grace_client.events("gid: GW150914") events = grace_client.events("GW150914") events = grace_client.events("is_gw: True") events = grace_client.events("is_gw") print(count_iterable(events)) results = {} for event in events: grace_id = event.get(GRACE_ID_KEY) results.update({grace_id: event}) return results
def process(self, config=GWSummConfigParser(), **kwargs): try: from ligo.gracedb.rest import GraceDb from ligo.gracedb.exceptions import HTTPError except ImportError as e: e.args = ('%s, this module is required to generate a GraceDbTab' % str(e), ) raise # query gracedb service_url = '%s/api/' % self.url connection = GraceDb(service_url=service_url) vprint("Connected to gracedb at %s\n" % service_url) try: self.events[None] = list(connection.superevents(self.query)) self._query_type = "S" except HTTPError: self.events[None] = list(connection.events(self.query)) event_method = connection.event eventid_name = "graceid" self._query_type = "E" else: event_method = connection.superevent eventid_name = "superevent_id" for event in self.events[None]: # get preferred event parameters event.update( connection.event(event["preferred_event"], ).json()) vprint("Recovered %d events for query %r\n" % (len(self.events[None]), self.query)) if 'labels' in self.columns: for e in self.events[None]: e['labels'] = ', '.join( event_method(e[eventid_name]).json()['labels']) vprint("Downloaded labels\n") return super(GraceDbTab, self).process(config=config, **kwargs)
def process(self, config=GWSummConfigParser(), **kwargs): try: from ligo.gracedb.rest import GraceDb from ligo.gracedb.exceptions import HTTPError except ImportError as e: e.args = ('%s, this module is required to generate a GraceDbTab' % str(e),) raise # query gracedb service_url = '%s/api/' % self.url connection = GraceDb(service_url=service_url) vprint("Connected to gracedb at %s\n" % service_url) try: self.events[None] = list(connection.superevents(self.query)) self._query_type = "S" except HTTPError: self.events[None] = list(connection.events(self.query)) event_method = connection.event eventid_name = "graceid" self._query_type = "E" else: event_method = connection.superevent eventid_name = "superevent_id" for event in self.events[None]: # get preferred event parameters event.update(connection.event( event["preferred_event"], ).json()) vprint("Recovered %d events for query %r\n" % (len(self.events[None]), self.query)) if 'labels' in self.columns: for e in self.events[None]: e['labels'] = ', '.join(event_method( e[eventid_name]).json()['labels']) vprint("Downloaded labels\n") return super(GraceDbTab, self).process(config=config, **kwargs)
def process(self, config=GWSummConfigParser(), **kwargs): try: from ligo.gracedb.rest import GraceDb except ImportError as e: e.args = ('%s, this module is required to generate a GraceDbTab' % str(e), ) raise # query gracedb service_url = '%s/api/' % self.url connection = GraceDb(service_url=service_url) vprint("Connected to gracedb at %s\n" % connection.service_url) querystr = '%s %d .. %d' % (self.query, self.start, self.end) self.events[None] = list(connection.events(querystr)) vprint("Recovered %d events for query %r\n" % (len(self.events[None]), querystr)) if 'labels' in self.columns: for e in self.events[None]: e['labels'] = ', '.join( connection.event(e['graceid']).json()['labels']) vprint("Downloaded labels\n") return super(GraceDbTab, self).process(config=config, **kwargs)
def process(self, config=GWSummConfigParser(), **kwargs): try: from ligo.gracedb.rest import GraceDb except ImportError as e: e.args = ('%s, this module is required to generate a GraceDbTab' % str(e),) raise # query gracedb service_url = '%s/api/' % self.url connection = GraceDb(service_url=service_url) vprint("Connected to gracedb at %s\n" % connection.service_url) querystr = '%s %d .. %d' % (self.query, self.start, self.end) self.events[None] = list(connection.events(querystr)) vprint("Recovered %d events for query %r\n" % (len(self.events[None]), querystr)) if 'labels' in self.columns: for e in self.events[None]: e['labels'] = ', '.join(connection.event( e['graceid']).json()['labels']) vprint("Downloaded labels\n") return super(GraceDbTab, self).process(config=config, **kwargs)
def get_event(params): g = GraceDb() eventString = params["event"] events = g.events('%s' % eventString) event = [x for x in events][0] keys = [ 'graceid', 'gpstime', 'extra_attributes', 'group', 'links', 'created', 'far', 'instruments', 'labels', 'nevents', 'submitter', 'search', 'likelihood' ] fileorder = [ 'LALInference_skymap.fits.gz', 'bayestar.fits.gz', 'BW_skymap.fits', 'LIB_skymap.fits.gz', 'skyprobcc_cWB.fits' ] #fileorder = ['LALInference3d.fits.gz','bayestar3d.fits.gz','bayestar.fits.gz'] fileorder = [ 'LALInference_skymap.fits.gz', 'bayestar.fits.gz', 'BW_skymap.fits', 'LIB_skymap.fits.gz', 'skyprobcc_cWB.fits' ] eventinfo = {} for key in keys: if not key in event: continue eventinfo[key] = event[key] eventinfo['gpstime'] = float(eventinfo['gpstime']) if eventinfo['far'] == None: eventinfo['far'] = np.nan triggerfile = "%s/%s.txt" % (params["outputDir"], eventinfo['graceid']) skymapfile = '%s/%s.fits' % (params["outputDir"], eventinfo['graceid']) #if os.path.isfile(triggerfile) and os.path.isfile(skymapfile): # print "Already have info for %s... continuing."%event["graceid"] # return print "Getting info for %s" % event["graceid"] mjds = [-1, -1] timediff = -1 if 'CoincInspiral' in event['extra_attributes']: eventinfo['coinc'] = event['extra_attributes']['CoincInspiral'] if 'SingleInspiral' in event['extra_attributes']: eventinfo['singles'] = {} for single in event['extra_attributes']['SingleInspiral']: eventinfo['singles'][single['ifo']] = single eventinfo['singles'][single['ifo']]['gpstime'] = single[ 'end_time'] + 10**-9 * single['end_time_ns'] if ("H1" in eventinfo['singles']) and ("L1" in eventinfo['singles']): eventinfo["H1_L1_difference"] = eventinfo['singles']['H1'][ "gpstime"] - eventinfo['singles']['L1']["gpstime"] t = Time([ eventinfo['singles']['H1']["gpstime"], eventinfo['singles']['L1']["gpstime"] ], format='gps', scale='utc') mjds = t.mjd timediff = eventinfo["H1_L1_difference"] if 'MultiBurst' in event['extra_attributes']: eventinfo['burst'] = event['extra_attributes']['MultiBurst'] single_ifo_times = eventinfo['burst']['single_ifo_times'].split(",") ifos = eventinfo['burst']['ifos'].split(",") if len(ifos) > 1 and len(single_ifo_times) > 1: ifo1 = ifos[0] gps1 = float(single_ifo_times[0]) ifo2 = ifos[1] gps2 = float(single_ifo_times[1]) eventinfo['burst'][ifo1] = {} eventinfo['burst'][ifo1]['gpstime'] = gps1 eventinfo['burst'][ifo2] = {} eventinfo['burst'][ifo2]['gpstime'] = gps2 if ("H1" in eventinfo['burst']) and ("L1" in eventinfo['burst']): eventinfo["H1_L1_difference"] = eventinfo['burst']['H1'][ "gpstime"] - eventinfo['burst']['L1']["gpstime"] t = Time([ eventinfo['burst']['H1']["gpstime"], eventinfo['burst']['L1']["gpstime"] ], format='gps', scale='utc') mjds = t.mjd timediff = eventinfo["H1_L1_difference"] try: print "Looking for EM bright file..." r = g.files(eventinfo['graceid'], "Source_Classification_%s.json" % eventinfo['graceid']) emfile = open('embright.json', 'w') emfile.write(r.read()) emfile.close() with open('embright.json') as data_file: emdata = json.load(data_file) os.system('rm embright.json') embright_keys = [ "Prob remnant_mass_greater_than 0M_sun", "Prob EMbright" ] ns_keys = ["Prob Mass2_less_than 3M_sun", "Prob NS2"] embright_prob = -1 for key in embright_keys: if not key in embright_keys: continue embright_prob = emdata[key] break ns_prob = -1 for key in embright_keys: if not key in embright_keys: continue ns_prob = emdata[key] break eventinfo['embright'] = {} eventinfo['embright']['embright'] = embright_prob eventinfo['embright']['ns'] = ns_prob except: print "No EM bright file..." try: print "Looking for cWB file..." r = g.files(eventinfo['graceid'], "trigger_%.4f.txt" % eventinfo['gpstime']) # r = g.files(eventinfo['graceid'], "eventDump.txt") cwbfile = open('trigger.txt', 'w') cwbfile.write(r.read()) cwbfile.close() eventinfo['burst'] = {} lines = [line.rstrip('\n') for line in open('trigger.txt')] for line in lines: lineSplit = line.split(":") if len(lineSplit) < 2: continue key = lineSplit[0] value = filter(None, lineSplit[1].split(" ")) eventinfo['burst'][lineSplit[0]] = value ifo1 = eventinfo['burst']['ifo'][0] gps1 = float(eventinfo['burst']['time'][0]) ifo2 = eventinfo['burst']['ifo'][1] gps2 = float(eventinfo['burst']['time'][1]) eventinfo['burst'][ifo1] = {} eventinfo['burst'][ifo1]['gpstime'] = gps1 eventinfo['burst'][ifo2] = {} eventinfo['burst'][ifo2]['gpstime'] = gps2 if ("H1" in eventinfo['burst']) and ("L1" in eventinfo['burst']): eventinfo["H1_L1_difference"] = eventinfo['burst']['H1'][ "gpstime"] - eventinfo['burst']['L1']["gpstime"] t = Time([ eventinfo['burst']['H1']["gpstime"], eventinfo['burst']['L1']["gpstime"] ], format='gps', scale='utc') mjds = t.mjd timediff = eventinfo["H1_L1_difference"] except: print "No cWB file..." ra = 0 dec = 0 r = [] for lvfile in fileorder: #r = g.files(eventinfo['graceid'], lvfile) try: r = g.files(eventinfo['graceid'], lvfile) break except: continue if r == []: print "Download of skymaps file for %s failed..." % eventinfo['graceid'] else: skymap = open(skymapfile, 'w') skymap.write(r.read()) skymap.close() return skymapfile, eventinfo
#!/usr/bin/env python3 from ligo.gracedb.rest import GraceDb client = GraceDb() # Retrieve an iterator for events matching a query. events = client.events("gstlal ER5 far < 1.0e-4") # For each event in the search results, add the graceid # and chirp mass to a dictionary. results = {} for event in events: graceid = event["graceid"] mchirp = event["extra_attributes"]["CoincInspiral"]["mchirp"] results.update({graceid: mchirp}) # For each super event in the search results, add the superevent_id # and chirp mass to a dictionary. superevents = client.superevents("gstlal ER5 far < 1.0e-4") s_results = {} for superevent in superevents: superevent_id = superevent["superevent_id"] mchirp = superevent["extra_attributes"]["CoincInspiral"]["mchirp"] s_results.update({superevent_id: mchirp})
class GraceDbTab(get_tab('default')): """Custom tab displaying a summary of GraceDb results. """ type = 'gracedb' def __init__(self, name, url='https://gracedb.ligo.org', query='External', columns=['gpstime', 'date', 'pipeline'], headers=['GPS time', 'UTC time', 'Source'], rank='gpstime', **kwargs): super(GraceDbTab, self).__init__(name, **kwargs) self.url = url self.query = '{} {} .. {}'.format( query, int(self.start), int(self.end), ) self.events = dict() self.headers = headers self.columns = columns self.rank = rank @classmethod def from_ini(cls, config, section, **kwargs): """Define a new `GraceDbTab` from a `ConfigParser`. """ for key in ['url', 'query', 'rank']: try: kwargs.setdefault( key, re_quote.sub('', config.get(section, key))) except NoOptionError: pass for key in ['columns', 'headers']: try: raw = config.get(section, key) val = eval(raw) except NoOptionError: continue except (SyntaxError, NameError, TypeError): val = [x.strip().rstrip() for x in raw.split(',')] kwargs.setdefault(key, val) return super(GraceDbTab, cls).from_ini(config, section, **kwargs) def process(self, config=GWSummConfigParser(), **kwargs): try: from ligo.gracedb.rest import GraceDb from ligo.gracedb.exceptions import HTTPError except ImportError as e: e.args = ('%s, this module is required to generate a GraceDbTab' % str(e),) raise # query gracedb service_url = '%s/api/' % self.url self.connection = GraceDb(service_url=service_url) self.exception = HTTPError vprint('Connected to gracedb at %s\n' % service_url) try: self.events[None] = list(self.connection.superevents(self.query)) self._query_type = 'S' except self.exception: self.events[None] = list(self.connection.events(self.query)) event_method = self.connection.event eventid_name = 'graceid' self._query_type = 'E' else: event_method = self.connection.superevent eventid_name = 'superevent_id' for event in self.events[None]: # get preferred event parameters event.update(self.connection.event( event['preferred_event'], ).json()) vprint('Recovered %d events for query %r\n' % (len(self.events[None]), self.query)) if 'labels' in self.columns: for e in self.events[None]: e['labels'] = ', '.join(event_method( e[eventid_name]).json()['labels']) vprint('Downloaded labels\n') return super(GraceDbTab, self).process(config=config, **kwargs) def process_state(self, state, **kwargs): def in_state(event): return int(event['gpstime']) in state.active self.events[str(state)] = list(filter(in_state, self.events[None])) reverse = self.rank not in ['gpstime', 'far'] self.events[str(state)].sort(key=lambda x: x[self.rank], reverse=reverse) vprint(' Selected %d events\n' % len(self.events[str(state)])) def write_state_html(self, state): """Write the '#main' HTML content for this `GraceDbTab`. """ page = markup.page() # build table of events page.table(class_='table table-sm table-hover table-striped mt-2', id_='gracedb') # thead page.thead() page.tr() for head in self.headers: page.th(head) page.tr.close() page.thead.close() # tbody page.tbody() for event in sorted(self.events[str(state)], key=lambda e: e['gpstime']): context = None try: labs = set(event['labels'].split(', ')) except (AttributeError, KeyError): pass else: for ctx, labels in LABELS.items(): if ( ctx == 'success' and labs.union(labels) == labs or labs.intersection(labels) ): context = ctx break if context: page.tr(class_='table-%s' % context) else: page.tr() for col in self.columns: if col == 'date': gpskey = 't_0' if 'superevent_id' in event else 'gpstime' page.td(from_gps(event[gpskey]).strftime( '%B %d %Y %H:%M:%S.%f', )[:-3]) continue elif col.lower() == 'dqr' and 'superevent_id' in event: page.td() sid = event['superevent_id'] href = ('{0}/apiweb/superevents/{1}/files/' 'dqr.html'.format(self.url, sid)) try: self.connection.get(href) except self.exception: page.p('—') else: title = 'Data-quality report for {}'.format(sid) page.a('DQR', title=title, href=href, target='_blank', rel='external', class_='btn btn-info btn-sm') page.td.close() continue elif col.lower() == 'dqr': page.td() page.p('—') page.td.close() continue try: v = event[col] except KeyError: try: v = event['extra_attributes']['GRB'][col] assert v is not None except (KeyError, AssertionError): page.td('-') continue if col in ('graceid', 'superevent_id', 'preferred_event'): page.td() tag = 'superevents' if col == 'superevent_id' else 'events' href = '{}/{}/view/{}'.format(self.url, tag, v) title = 'GraceDB {} page for {}'.format(tag[:-1], v) page.a(v, title=title, href=href, target='_blank', rel='external', class_='btn btn-info btn-sm') page.td.close() elif col not in ('gpstime', 't_0') and isinstance(v, float): page.td('%.3g' % v) elif col == 'labels': page.td(', '.join( ['<samp>%s</samp>' % l for l in sorted(labs)])) else: page.td(str(v)) page.tr.close() page.tbody.close() page.table.close() if len(self.events[str(state)]) == 0: page.p('No events were recovered for this state.') else: page.button( 'Export to CSV', class_='btn btn-outline-secondary btn-table mt-2', **{'data-table-id': 'gracedb', 'data-filename': 'gracedb.csv'}) # query doc qurl = '{}/search/?query={}&query_type={}&results_format=S'.format( self.url, self.query.replace(' ', '+'), getattr(self, '_query_type', 'E'), ) qlink = markup.oneliner.a( 'here', href=qurl, target='_blank', ) page.p('The above table was generated from a query to {} with the ' 'form <code>{}</code>. To view the results of the same query ' 'via the GraceDB web interface, click {}.'.format( self.url, self.query, qlink), class_='mt-2') # reference the labelling page.h4('Labelling reference') page.p('Events in the above table may have a context based on ' 'its labels as follows:') for c, labels in LABELS.items(): c = (c if c == 'warning' else '%s text-white' % c) labstr = ', '.join(['<samp>%s</samp>' % l for l in sorted(labels)]) page.p(labstr, class_='bg-%s pl-2' % c, style='width: auto;') # write to file idx = self.states.index(state) with open(self.frames[idx], 'w') as fobj: fobj.write(str(page)) return self.frames[idx]
def parseAlert(queue, queueByGraceID, alert, t0, config): ''' the way approval_processorMP digests lvalerts --> check if this alert is a command and delegate to parseCommand 1) instantiates GraceDB client 2) pulls childConfig settings 3) makes sure we have the logger 4) get lvalert specifics 5) ensure we have the event_dict for the graceid = lvalert['uid'] 6) take proper action depending on the lvalert info coming in and currentstate of the event_dict ''' #------------------------------------------------------------------- # process commands sent via lvalert_commandMP #------------------------------------------------------------------- if alert['uid'] == 'command': ### this is a command message! return parseCommand(queue, queueByGraceID, alert, t0) ### delegate to parseCommand and return #------------------------------------------------------------------- # extract relevant config parameters and set up necessary data structures #------------------------------------------------------------------- # instantiate GraceDB client from the childConfig client = config.get('general', 'client') g = GraceDb(client) # get other childConfig settings; save in configdict voeventerror_email = config.get('general', 'voeventerror_email') force_all_internal = config.get('general', 'force_all_internal') preliminary_internal = config.get('general', 'preliminary_internal') forgetmenow_timeout = config.getfloat('general', 'forgetmenow_timeout') approval_processorMPfiles = config.get('general', 'approval_processorMPfiles') hardware_inj = config.get('labelCheck', 'hardware_inj') wait_for_hardware_inj = config.getfloat('labelCheck', 'wait_for_hardware_inj') default_farthresh = config.getfloat('farCheck', 'default_farthresh') time_duration = config.getfloat('injectionCheck', 'time_duration') humanscimons = config.get('operator_signoffCheck', 'humanscimons') ### extract options about advocates advocates = config.get('advocate_signoffCheck', 'advocates') advocate_text = config.get('advocate_signoffCheck', 'advocate_text') advocate_email = config.get('advocate_signoffCheck', 'advocate_email') ### extract options for GRB alerts em_coinc_text = config.get('GRB_alerts', 'em_coinc_text') coinc_text = config.get('GRB_alerts', 'coinc_text') grb_email = config.get('GRB_alerts', 'grb_email') notification_text = config.get('GRB_alerts', 'notification_text') ### extract options about idq ignore_idq = config.get('idq_joint_fapCheck', 'ignore_idq') default_idqthresh = config.getfloat('idq_joint_fapCheck', 'default_idqthresh') idq_pipelines = config.get('idq_joint_fapCheck', 'idq_pipelines') idq_pipelines = idq_pipelines.replace(' ', '') idq_pipelines = idq_pipelines.split(',') skymap_ignore_list = config.get('have_lvem_skymapCheck', 'skymap_ignore_list') ### set up configdict (passed to local data structure: eventDicts) configdict = makeConfigDict(config) # set up logging ### FIXME: why not open the logger each time parseAlert is called? ### that would allow you to better control which loggers are necessary and minimize the number of open files. ### it also minimizes the possibility of something accidentally being written to loggers because they were left open. ### what's more, this is a natural place to set up multiple loggers, one for all data and one for data pertaining only to this graceid global logger if globals().has_key('logger'): # check to see if we have logger logger = globals()['logger'] else: # if not, set one up logger = loadLogger(config) logger.info( '\n{0} ************ approval_processorMP.log RESTARTED ************\n' .format(convertTime())) #------------------------------------------------------------------- # extract relevant info about this alert #------------------------------------------------------------------- # get alert specifics and event_dict information graceid = alert['uid'] alert_type = alert['alert_type'] description = alert['description'] filename = alert['file'] #------------------------------------------------------------------- # ensure we have an event_dict and ForgetMeNow tracking this graceid #------------------------------------------------------------------- if alert_type == 'new': ### new event -> we must first create event_dict and set up ForgetMeNow queue item for G events ### create event_dict event_dict = EventDict( ) # create a new instance of EventDict class which is a blank event_dict if is_external_trigger( alert) == True: # this is an external GRB trigger event_dict.grb_trigger_setup( alert['object'], graceid, g, config, logger ) # populate this event_dict with grb trigger info from lvalert else: event_dict.setup( alert['object'], graceid, configdict, g, config, logger ) # populate this event_dict with information from lvalert eventDicts[ graceid] = event_dict # add the instance to the global eventDicts eventDictionaries[ graceid] = event_dict.data # add the dictionary to the global eventDictionaries ### ForgetMeNow queue item item = ForgetMeNow(t0, forgetmenow_timeout, graceid, eventDicts, queue, queueByGraceID, logger) queue.insert(item) # add queue item to the overall queue ### set up queueByGraceID newSortedQueue = utils.SortedQueue( ) # create sorted queue for event candidate newSortedQueue.insert( item) # put ForgetMeNow queue item into the sorted queue queueByGraceID[ item. graceid] = newSortedQueue # add queue item to the queueByGraceID saveEventDicts( approval_processorMPfiles ) # trying to see if expirationtime is updated from None message = '{0} -- {1} -- Created event dictionary for {1}.'.format( convertTime(), graceid) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: Created event dictionary.', tagname='em_follow') else: pass else: ### not a new alert -> we may already be tracking this graceid if eventDicts.has_key(graceid): ### we're already tracking it # get event_dict with expirationtime key updated for the rest of parseAlert event_dict = eventDicts[graceid] # find ForgetMeNow corresponding to this graceid and update expiration time for item in queueByGraceID[graceid]: if item.name == ForgetMeNow.name: # selects the queue item that is a ForgetMeNow instance item.setExpiration(t0) # updates the expirationtime key queue.resort( ) ### may be expensive, but is needed to guarantee that queue remains sorted queueByGraceID[graceid].resort() break else: ### we couldn't find a ForgetMeNow for this event! Something is wrong! os.system( 'echo \'ForgetMeNow KeyError\' | mail -s \'ForgetMeNow KeyError {0}\' {1}' .format(graceid, advocate_email)) raise KeyError( 'could not find ForgetMeNow for %s' % graceid ) ### Reed thinks this is necessary as a safety net. ### we want the process to terminate if things are not set up correctly to force us to fix it else: # event_dict for event candidate does not exist. we need to create it with up-to-date information event_dict = EventDict( ) # create a new instance of the EventDict class which is a blank event_dict if is_external_trigger(alert) == True: event_dict.grb_trigger_setup( g.events(graceid).next(), graceid, g, config, logger) else: event_dict.setup( g.events(graceid).next(), graceid, configdict, g, config, logger ) # fill in event_dict using queried event candidate dictionary event_dict.update( ) # update the event_dict with signoffs and iDQ info eventDicts[ graceid] = event_dict # add this instance to the global eventDicts eventDictionaries[ graceid] = event_dict.data # add the dictionary to the global eventDictionaries # create ForgetMeNow queue item and add to overall queue and queueByGraceID item = ForgetMeNow(t0, forgetmenow_timeout, graceid, eventDicts, queue, queueByGraceID, logger) queue.insert(item) # add queue item to the overall queue ### set up queueByGraceID newSortedQueue = utils.SortedQueue( ) # create sorted queue for new event candidate newSortedQueue.insert( item) # put ForgetMeNow queue item into the sorted queue queueByGraceID[ item. graceid] = newSortedQueue # add queue item to the queueByGraceID message = '{0} -- {1} -- Created event dictionary for {1}.'.format( convertTime(), graceid) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: Created event dictionary.', tagname='em_follow') else: pass #-------------------- # ignore alerts that are not relevant, like simulation or MDC events #-------------------- # if the graceid starts with 'M' for MDCs or 'S' for Simulation, ignore if re.match('M', graceid) or re.match( 'S', graceid): ### FIXME: we want to make this a config-file option! message = '{0} -- {1} -- Mock data challenge or simulation. Ignoring.'.format( convertTime(), graceid) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: Mock data challenge or simulation. Ignoring.', tagname='em_follow') else: pass saveEventDicts(approval_processorMPfiles) return 0 #-------------------- # take care of external GRB triggers #-------------------- if is_external_trigger( alert ) == True: # for now, grouped everything related to external triggers together below # if it's not a log message updating us about possible coincidence with gravitational-waves OR labels OR json file uploads we are not interested if alert_type == 'label': record_label(event_dict.data, description) if alert_type == 'update': # is this a comment containing coinc info that needs to be parsed? if 'comment' in alert['object'].keys(): comment = alert['object']['comment'] if 'Significant event in on-source' in comment: # got comment structure from Dipongkar coinc_pipeline, coinc_fap = record_coinc_info( event_dict.data, comment, alert, logger) # begin creating the dictionary that will turn into json file message_dict = {} # populate text field for the GCN circular-to-be message_dict['message'] = coinc_text.format( graceid, coinc_fap) message_dict['loaded_to_gracedb'] = 0 # make json string and file message_dict = json.dumps(message_dict) tmpfile = open('/tmp/coinc_{0}.json'.format(graceid), 'w') tmpfile.write(message_dict) tmpfile.close() # make sure to load with a comment that we look for to check off that it's been loaded into gracedb # was it an online or offline pipeline? if 'Online' in coinc_pipeline: event_dict.data['grb_online_json'] = message_dict g.writeLog( graceid, 'GRB-GW Coincidence JSON file: grb_online_json', '/tmp/coinc_{0}.json'.format(graceid), tagname='em_follow') elif 'Offline' in coinc_pipeline: event_dict.data['grb_offline_json'] = message_dict g.writeLog( graceid, 'GRB-GW Coincidence JSON file: grb_offline_json', '/tmp/coinc_{0}.json'.format(graceid), tagname='em_follow') os.remove('/tmp/coinc_{0}.json'.format(graceid)) ### alert via email os.system( 'echo \{0}\' | mail -s \'Coincidence JSON created for {1}\' {2}' .format(notification_text, graceid, grb_email)) # is this the json file loaded into GraceDb? if 'GRB-GW Coincidence JSON file' in comment: # if it is, find out which type of json it was and then message_dict['loaded_to_gracedb'] = 1 json_type = re.findall('file: (.*)', comment)[0] message_dict = event_dict.data[json_type] message_dict = json.loads( message_dict) # converts string to dictionary message_dict['loaded_to_gracedb'] = 1 # when we send to observers, message_dict['sent_to_observers'] = 1 else: pass saveEventDicts(approval_processorMPfiles) return 0 #-------------------- # Appending which checks must be satisfied in preliminary_to_initial state before moving on #-------------------- if humanscimons == 'yes': preliminary_to_initial.append('operator_signoffCheck') if advocates == 'yes': preliminary_to_initial.append('advocate_signoffCheck') #-------------------- # update information based on the alert_type # includes extracting information from the alert # may also include generating VOEvents and issuing them #-------------------- # actions for each alert_type currentstate = event_dict.data[ 'currentstate'] ### actions depend on the current state ### NOTE: we handle alert_type=="new" above as well and this conditional is slightly redundant... if alert_type == 'new': #---------------- ### pass event through PipelineThrottle #---------------- ### check if a PipelineThrottle exists for this node group = event_dict.data['group'] pipeline = event_dict.data['pipeline'] search = event_dict.data['search'] key = generate_ThrottleKey(group, pipeline, search=search) if queueByGraceID.has_key(key): ### a throttle already exists if len(queueByGraceID[key]) > 1: raise ValueError( 'too many QueueItems in SortedQueue for pipelineThrottle key=%s' % key) item = queueByGraceID[key][ 0] ### we expect there to be only one item in this SortedQueue else: ### we need to make a throttle! # pull PipelineThrottle parameters from the config if config.has_section(key): throttleWin = config.getfloat(key, 'throttleWin') targetRate = config.getfloat(key, 'targetRate') requireManualReset = config.get(key, 'requireManualReset') conf = config.getfloat(key, 'conf') else: throttleWin = config.getfloat('default_PipelineThrottle', 'throttleWin') targetRate = config.getfloat('default_PipelineThrottle', 'targetRate') requireManualReset = config.get('default_PipelineThrottle', 'requireManualReset') conf = config.getfloat('default_PipelineThrottle', 'conf') item = PipelineThrottle(t0, throttleWin, targetRate, group, pipeline, search=search, requireManualReset=False, conf=0.9, graceDB_url=client) queue.insert(item) ### add to overall queue newSortedQueue = utils.SortedQueue( ) # create sorted queue for event candidate newSortedQueue.insert( item) # put ForgetMeNow queue item into the sorted queue queueByGraceID[ item. graceid] = newSortedQueue # add queue item to the queueByGraceID item.addEvent(graceid, t0) ### add new event to throttle ### this takes care of labeling in gracedb as necessary if item.isThrottled(): ### send some warning message? return 0 ### we're done here because we're ignoring this event -> exit from parseAlert # #---------------- # ### pass data to Grouper # #---------------- # raise Warning("Grouper is not implemented yet! we're currently using a temporate groupTag and prototype code") # ''' # need to extract groupTag from group_pipeline[_search] mapping. # These associations should be specified in the config file, so we'll have to specify this somehow. # probably just a "Grouper" section, with (option = value) pairs that look like (groupTag = nodeA nodeB nodeC ...) # ''' # groupTag = 'TEMPORARY' # ### check to see if Grouper exists for this groupTag # if queueByGraceID.has_key(groupTag): ### at least one Grouper already exists # ### determine if any of the existing Groupers are still accepting new triggers # for item in queueByGraceID[groupTag]: # if item.isOpen(): # break ### this Grouper is still open, so we'll just use it # else: ### no Groupers are open, so we need to create one # item = Grouper(t0, grouperWin, groupTag, eventDicts, graceDB_url=client) ### create the actual QueueItem # queue.insert( item ) ### insert it in the overall queue # newSortedQueue = utils.SortedQueue() ### set up the SortedQueue for queueByGraceID # newSortedQueue.insert(item) # queueByGraceID[groupTag] = newSortedQueue # else: ### we need to make a Grouper # grouperWin = config.getfloat('grouper', 'grouperWin') # item = Grouper(t0, grouperWin, groupTag, eventDicts, graceDB_url=client) ### create the actual QueueItem # queue.insert( item ) ### insert it in the overall queue # newSortedQueue = utils.SortedQueue() ### set up the SortedQueue for queueByGraceID # newSortedQueue.insert(item) # queueByGraceID[groupTag] = newSortedQueue # item.addEvent( graceid ) ### add this graceid to the item return 0 ### we're done here. When Grouper makes a decision, we'll tick through the rest of the processes with a "selected" label elif alert_type == 'label': record_label(event_dict.data, description) if description == 'PE_READY': ### PE_READY label was just applied. We may need to send an update alert message = '{0} -- {1} -- Sending update VOEvent.'.format( convertTime(), graceid) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog( graceid, 'AP: Received PE_READY label. Sending update VOEvent.', tagname='em_follow') process_alert(event_dict.data, 'update', g, config, logger) else: pass message = '{0} -- {1} -- State: {2} --> complete.'.format( convertTime(), graceid, currentstate) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: State: {0} --> complete.'.format(currentstate), tagname='em_follow') event_dict.data['currentstate'] = 'complete' else: pass elif description == 'EM_READY': ### EM_READY label was just applied. We may need to send an initial alert message = '{0} -- {1} -- Sending initial VOEvent.'.format( convertTime(), graceid) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog( graceid, 'AP: Received EM_READY label. Sending initial VOEvent.', tagname='em_follow') process_alert(event_dict.data, 'initial', g, config, logger) else: pass message = '{0} -- {1} -- State: {2} --> initial_to_update.'.format( convertTime(), graceid, currentstate) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: State: {0} --> initial_to_update.'.format( currentstate), tagname='em_follow') event_dict.data['currentstate'] = 'initial_to_update' else: pass elif description == "EM_Throttled": ### the event is throttled and we need to turn off all processing for it event_dict.data[ 'currentstate'] = 'throttled' ### update current state ### check if we need to send retractions voevents = event_dict.data['voevents'] if len(voevents) > 0: if 'retraction' not in sorted(voevents)[-1]: # there are existing VOEvents we've sent, but no retraction alert process_alert(event_dict.data, 'retraction', g, config, logger) ### update ForgetMeNow expiration to handle all the clean-up? ### we probably do NOT want to change the clean-up schedule because we'll still likely receive a lot of alerts about this guy ### therefore, we just retain the local data and ignore him, rather than erasing the local data and having to query to reconstruct it repeatedly as new alerts come in # for item in queueByGraceID[graceid]: ### update expiration of the ForgetMeNow so it is immediately processed next. # if item.name == ForgetMeNow.name: # time.setExpiration(-np.infty ) # ### FIXME: this can break the order in SortedQueue's. We need to pop and reinsert or call a manual resort # queue.resort() ### may be expensive but is needed to guarantee that queue remains sorted # queueByGraceID[graceid].resort() # break # else: # raise ValueError('could not find ForgetMeNow QueueItem for graceid=%s'%graceid) elif description == "EM_Selected": ### this event was selected by a Grouper raise NotImplementedError( 'write logic to handle \"Selected\" labels') elif description == "EM_Superseded": ### this event was superceded by another event within Grouper raise NotImplementedError( 'write logic to handle \"Superseded" labels') elif ( checkLabels(description.split(), config) > 0 ): ### some other label was applied. We may need to issue a retraction notice. event_dict.data['currentstate'] = 'rejected' ### check to see if we need to send a retraction voevents = event_dict.data['voevents'] if len(voevents) > 0: if 'retraction' not in sorted(voevents[-1]): # there are existing VOEvents we've sent, but no retraction alert process_alert(event_dict.data, 'retraction', g, config, logger) saveEventDicts( approval_processorMPfiles) ### save the updated eventDict to disk return 0 ### FIXME: Reed left off commenting here... elif alert_type == 'update': # first the case that we have a new lvem skymap if (filename.endswith('.fits.gz') or filename.endswith('.fits')): if 'lvem' in alert['object'][ 'tag_names']: # we only care about skymaps tagged lvem for sharing with MOU partners submitter = alert['object']['issuer'][ 'display_name'] # in the past, we used to care who submitted skymaps; keeping this functionality just in case record_skymap(event_dict.data, filename, submitter, logger) else: pass # interested in iDQ information or other updates else: if 'comment' in alert['object'].keys(): comment = alert['object']['comment'] if re.match( 'minimum glitch-FAP', comment ): # looking to see if it's iDQ glitch-FAP information record_idqvalues(event_dict.data, comment, logger) elif re.match( 'resent VOEvent', comment ): # looking to see if another running instance of approval_processorMP sent a VOEvent response = re.findall( r'resent VOEvent (.*) in (.*)', comment) # extracting which VOEvent was re-sent event_dict.data[response[0][1]].append(response[0][0]) saveEventDicts(approval_processorMPfiles) elif 'EM-Bright probabilities computed from detection pipeline' in comment: # got comment structure from Shaon G. record_em_bright(event_dict.data, comment, logger) elif 'Temporal coincidence with external trigger' in comment: # got comment structure from Alex U. exttrig, coinc_far = record_coinc_info( event_dict.data, comment, alert, logger) # create dictionary that will become json file message_dict = {} grb_instrument = eventDictionaries[exttrig]['pipeline'] message_dict['message'] = em_coinc_text.format( exttrig, grb_instrument, graceid, coinc_far) message_dict['loaded_to_gracedb'] = 0 message_dict = json.dumps(message_dict) # update event dictionaries for both the gw and external trigger eventDictionaries[exttrig][ 'em_coinc_json'] = message_dict # this updates the external trigger event_dict.data event_dict.data[ 'em_coinc_json'] = message_dict # this updates the gw trigger event_dict.data # load json file to the gw gracedb page tmpfile = open('/tmp/coinc_{0}.json'.format(graceid), 'w') tmpfile.write(message_dict) tmpfile.close() g.writeLog(graceid, 'GRB-GW Coincidence JSON file: em_coinc_json', '/tmp/coinc_{0}.json'.format(graceid), tagname='em_follow') os.remove('/tmp/coinc_{0}.json'.format(graceid)) # load json file to the external trigger page tmpfile = open('/tmp/coinc_{0}.json'.format(exttrig), 'w') tmpfile.write(message_dict) tmpfile.close() g.writeLog(exttrig, 'GRB-GW Coincidence JSON file: em_coinc_json', '/tmp/coinc_{0}.json'.format(exttrig), tagname='em_follow') os.remove('/tmp/coinc_{0}.json'.format(exttrig)) ### alert via email os.system( 'echo \{0}\' | mail -s \'Coincidence JSON created for {1}\' {2}' .format(notification_text, exttrig, grb_email)) saveEventDicts(approval_processorMPfiles) elif 'GRB-GW Coincidence JSON file' in comment: # this is the comment that accompanies a loaded coinc json file message_dict = event_dict.data['em_coinc_json'] message_dict = json.loads( message_dict) # converts string to dictionary message_dict['loaded_to_gracedb'] = 1 saveEventDicts(approval_processorMPfiles) else: pass elif alert_type == 'signoff': signoff_object = alert['object'] record_signoff(event_dict.data, signoff_object) #--------------------------------------------- # run checks specific to currentstate of the event candidate #--------------------------------------------- passedcheckcount = 0 if currentstate == 'new_to_preliminary': time.sleep( wait_for_hardware_inj ) #this is for those cases where we dont have the INJ label right away queried_dict = g.events(graceid).next() #query gracedb for the graceid event_dict.data['labels'] = queried_dict['labels'].keys( ) #get the latest labels before running checks for Check in new_to_preliminary: eval('event_dict.{0}()'.format(Check)) checkresult = event_dict.data[Check + 'result'] if checkresult == None: pass elif checkresult == False: # because in 'new_to_preliminary' state, no need to apply DQV label message = '{0} -- {1} -- Failed {2} in currentstate: {3}.'.format( convertTime(), graceid, Check, currentstate) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: Failed {0} in currentstate: {1}.'.format( Check, currentstate), tagname='em_follow') else: pass message = '{0} -- {1} -- State: {2} --> rejected.'.format( convertTime(), graceid, currentstate) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog( graceid, 'AP: State: {0} --> rejected.'.format(currentstate), tagname='em_follow') event_dict.data['currentstate'] = 'rejected' else: pass saveEventDicts(approval_processorMPfiles) return 0 elif checkresult == True: passedcheckcount += 1 if passedcheckcount == len(new_to_preliminary): message = '{0} -- {1} -- Passed all {2} checks.'.format( convertTime(), graceid, currentstate) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: Passed all {0} checks.'.format(currentstate), tagname='em_follow') else: pass message = '{0} -- {1} -- Sending preliminary VOEvent.'.format( convertTime(), graceid) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: Sending preliminary VOEvent.', tagname='em_follow') process_alert(event_dict.data, 'preliminary', g, config, logger) else: pass message = '{0} -- {1} -- State: {2} --> preliminary_to_initial.'.format( convertTime(), graceid, currentstate) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: State: {0} --> preliminary_to_initial.'.format( currentstate), tagname='em_follow') event_dict.data['currentstate'] = 'preliminary_to_initial' else: pass labels = event_dict.data['labels'] # notify the operators if we haven't previously processed this event instruments = event_dict.data['instruments'] for instrument in instruments: if instrument in str(labels): pass else: message = '{0} -- {1} -- Labeling {2}OPS.'.format( convertTime(), graceid, instrument) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: Labeling {0}OPS.'.format(instrument), tagname='em_follow') g.writeLabel(graceid, '{0}OPS'.format(instrument)) else: pass # notify the advocates if we haven't previously processed this event if 'ADV' in str(labels): pass else: message = '{0} -- {1} -- Labeling ADVREQ.'.format( convertTime(), graceid) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: Labeling ADVREQ.', tagname='em_follow') g.writeLabel(graceid, 'ADVREQ') os.system( 'echo \'{0}\' | mail -s \'{1} passed criteria for follow-up\' {2}' .format(advocate_text, graceid, advocate_email)) # expose event to LV-EM url_perm_base = g.service_url + urllib.quote( 'events/{0}/perms/gw-astronomy:LV-EM:Observers/'. format(graceid)) for perm in ['view', 'change']: url = url_perm_base + perm #g.put(url) else: pass saveEventDicts(approval_processorMPfiles) return 0 elif currentstate == 'preliminary_to_initial': for Check in preliminary_to_initial: eval('event_dict.{0}()'.format(Check)) checkresult = event_dict.data[Check + 'result'] if checkresult == None: pass elif checkresult == False: message = '{0} -- {1} -- Failed {2} in currentstate: {3}.'.format( convertTime(), graceid, Check, currentstate) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: Failed {0} in currentstate: {1}.'.format( Check, currentstate), tagname='em_follow') else: pass message = '{0} -- {1} -- State: {2} --> rejected.'.format( convertTime(), graceid, currentstate) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog( graceid, 'AP: State: {0} --> rejected.'.format(currentstate), tagname='em_follow') event_dict.data['currentstate'] = 'rejected' else: pass # need to set DQV label so long as it isn't the operator_signoffCheck or advocate_signoffCheck if 'signoffCheck' in Check: message = '{0} -- {1} -- Not labeling DQV because signoffCheck is separate from explicit data quality checks.'.format( convertTime(), graceid) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog( graceid, 'AP: Not labeling DQV because signoffCheck is separate from explicit data quality checks.', tagname='em_follow') else: pass else: message = '{0} -- {1} -- Labeling DQV.'.format( convertTime(), graceid) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: Labeling DQV.', tagname='em_follow') g.writeLabel(graceid, 'DQV') else: pass saveEventDicts(approval_processorMPfiles) return 0 elif checkresult == True: passedcheckcount += 1 if Check == 'have_lvem_skymapCheck': # we want to send skymaps out as quickly as possible, even if humans have not vetted the event process_alert( event_dict.data, 'preliminary', g, config, logger ) # if it turns out we've sent this alert with this skymap before, the process_alert function will just not send this repeat if passedcheckcount == len(preliminary_to_initial): message = '{0} -- {1} -- Passed all {2} checks.'.format( convertTime(), graceid, currentstate) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: Passed all {0} checks.'.format(currentstate), tagname='em_follow') else: pass message = '{0} -- {1} -- Labeling EM_READY.'.format( convertTime(), graceid) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: Labeling EM_READY.', tagname='em_follow') g.writeLabel(graceid, 'EM_READY') else: pass saveEventDicts(approval_processorMPfiles) return 0 elif currentstate == 'initial_to_update': for Check in initial_to_update: eval('event_dict.{0}()'.format(Check)) checkresult = event_dict.data[Check + 'result'] if checkresult == None: pass elif checkresult == False: # need to set DQV label message = '{0} -- {1} -- Failed {2} in currentstate: {3}.'.format( convertTime(), graceid, Check, currentstate) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: Failed {0} in currentstate: {1}.'.format( Check, currentstate), tagname='em_follow') else: pass message = '{0} -- {1} -- State: {2} --> rejected.'.format( convertTime(), graceid, currentstate) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog( graceid, 'AP: State: {0} --> rejected.'.format(currentstate), tagname='em_follow') event_dict.data['currentstate'] = 'rejected' else: pass message = '{0} -- {1} -- Labeling DQV.'.format( convertTime(), graceid) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: Labeling DQV.', tagname='em_follow') g.writeLabel(graceid, 'DQV') else: pass saveEventDicts(approval_processorMPfiles) return 0 elif checkresult == True: passedcheckcount += 1 if passedcheckcount == len(initial_to_update): message = '{0} -- {1} -- Passed all {2} checks.'.format( convertTime(), graceid, currentstate) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: Passed all {0} checks.'.format(currentstate), tagname='em_follow') else: pass message = '{0} -- {1} -- Labeling PE_READY.'.format( convertTime(), graceid) if loggerCheck(event_dict.data, message) == False: logger.info(message) g.writeLog(graceid, 'AP: Labeling PE_READY.', tagname='em_follow') g.writeLabel(graceid, 'PE_READY') else: pass saveEventDicts(approval_processorMPfiles) return 0 else: saveEventDicts(approval_processorMPfiles) return 0
"-q", "--pipeline2", dest="pipeline2", default="mbtaonline", type="string", help="the pipeline we want when finding events in GraceDB", ) parser.add_option("-u", "--username", dest="username", default="None", type="string", help="LIGO username") parser.add_option("-w", "--password", dest="password", default="None", type="string", help="LIGO password") opts, args = parser.parse_args() boundaries = [opts.gpsstart, opts.gpsend, opts.far] pipeline = [opts.pipeline1, opts.pipeline2] username = opts.username password = opts.password all_events = [l for l in g.events(" %s .. %s far < %s" % tuple(boundaries)) if (l["pipeline"].lower() in pipeline)] # chooses events from GraceDb that are under a certain FAR threshold, in between two GPS times, and certain pipelines results = [] def open_url_wget(url, un=None, pw=None, args=[]): import subprocess import urlparse if un is not None and pw is not None: args += ["--user", un, "--password", pw, "--no-check-certificate"] retcode = subprocess.call(["wget"] + [url] + args) return retcode string = "%10s | %20s | %20s | %45s | %15s | %40s | %20s | %40s" % ( "graceid",
event_search = 'CBC ~Inj ' + str(time1) + ' .. ' + str(time2) try: from ligo.gracedb.rest import GraceDb except ImportError: print >> sys.stderr, "warning: gracedb import failed, program will crash if gracedb uploads are attempted" # set the gracedb server you want to download the events # playground is for testing, containing replay events back to Nov. 20, 2018 # main database: https://gracedb.ligo.org/api/" includes real candidates main_database = "gracedb" # either "gracedb" or "gracedb-playground" gracedb_service_url = "https://" + main_database + ".ligo.org/api/" gracedb_client = GraceDb(gracedb_service_url) events = gracedb_client.events(event_search) count = 0 for event in events: gid = event['graceid'] with open('data/' + str(gid), 'w') as f: count += 1 print(count) if event['superevent'] == None: superevent = u'none' else: superevent = event['superevent'] endtime = event['gpstime'] chirpmass = event['extra_attributes']['CoincInspiral']['mchirp'] farc = event['extra_attributes']['CoincInspiral']['combined_far'] snrc = event['extra_attributes']['CoincInspiral']['snr']
parser=OptionParser(usage = usage, description = description) parser.add_option('-v', '--verbose', default = False, action = "store_true") parser.add_option('-s', '--gpsstart', dest = "gpsstart", default = 0, type = "float", help = "the gps start time used when finding events in GraceDB") parser.add_option('-e', '--gpsend', dest = "gpsend", default = 0, type = "float", help = "the gps end time used when finding events in GraceDB") parser.add_option('-f', '--far', dest = "far", default = 0, type = "float", help = "the largest FAR value desired when finding events in GraceDB") parser.add_option('-p', '--pipeline1', dest = "pipeline1", default = 'gstlal', type = "string", help = "the pipeline we want when finding events in GraceDB") parser.add_option('-q', '--pipeline2', dest = "pipeline2", default = 'mbtaonline', type = "string", help = "the pipeline we want when finding events in GraceDB") parser.add_option('-u', '--username', dest = "username", default = 'None', type = "string", help = "LIGO username") parser.add_option('-w', '--password', dest = "password", default = 'None', type = "string", help = "LIGO password") opts, args = parser.parse_args() boundaries = [opts.gpsstart, opts.gpsend, opts.far] pipeline = [opts.pipeline1, opts.pipeline2] username = opts.username password = opts.password all_events = [ l for l in g.events(' %s .. %s far < %s'%tuple(boundaries)) if (l['pipeline'].lower() in pipeline ) ] #chooses events from GraceDb that are under a certain FAR threshold, in between two GPS times, and certain pipelines results = [] def open_url_wget(url,un=None,pw=None,args=[]): import subprocess import urlparse if un is not None and pw is not None: args+=["--user",un,"--password",pw,"--no-check-certificate"] retcode=subprocess.call(['wget']+[url]+args) return retcode string = "%10s | %20s | %20s | %45s | %15s | %40s | %20s | %40s"%("graceid", "far", "lalstart", "lalfinish", "snr", "lalsnr", "mchirp", "lalmchirp") #creates a header string to organize the array
# 1 day either side of known GW events: event_type = 'CBC 1126173062 .. 1126345862' #GW150914 #event_type = 'gstlal pycbc spiir MBTAOnline 1128592500 .. 1128765300'#GW151012 #event_type = 'CBC 1135049950 .. 1135222750'#GW151226 #event_type = 'CBC 1167473536 .. 1167646336'#GW170104 #event_type = 'CBC 1180836094 .. 1181008894'#GW170608 #event_type = 'CBC 1185303407 .. 1185476207'#GW170729 #event_type = 'gstlal MBTAOnline spiir 1186216119 .. 1186388919'#GW170809 #event_type = 'gstlal MBTAOnline spiir 1186655461 .. 1186828261'#GW170814 #event_type = 'gstlal MBTAOnline spiir 1186922482 .. 1187095282'#GW170817 #event_type = 'gstlal MBTAOnline spiir 1186971927 .. 1187144727'#GW170818 #event_type = 'CBC 1187442856 .. 1187615656'#GW170823 event_name = event_type.replace(' ', '_') # to get rid of those pesky white spaces print(' for events satisfying: ' + event_type) events = gracedb_client.events( event_type) # number of events consistent with spiir Nov 20 - Nov 31 with open('graceid-pipeline_' + event_name, 'w') as f: for event in events: gid = event['graceid'] pipe = event['pipeline'] f.write(gid + ' ' + pipe + '\n') fname = "%s.xml" % gid fout = open(fname, 'w+') content = gracedb_client.files(gid, filename="coinc.xml") fout.write(content.read()) fout.close() with open("name_log", "w") as f: f.write(main_database + "\n") f.write(event_name)
os.system(rm_command) # Instantiate client g = GraceDb() #g = GraceDb(url) #g = GraceDbBasic() #g = GraceDbBasic(url) eventString = get_eventstring(opts) if opts.doGPSLoop: opts.doGPS = True while True: endtime = Time(datetime.utcnow(), scale='utc') starttime = t = Time(endtime.gps - 86400.0, format='gps', scale='utc') opts.startGPS = starttime.gps opts.endGPS = endtime.gps eventString = get_eventstring(opts) # REST API returns an iterator events = g.events('%s'%eventString) download_events(events) else: eventString = get_eventstring(opts) print eventString # REST API returns an iterator events = g.events('%s'%eventString) download_events(events)