def get_injected_gps_time(self, site): if 'injected_%s_start_time' % site in self.__slots__: return LIGOTimeGPS(getattr(self, 'injected_%s_start_time' % site ), getattr(self, 'injected_%s_start_time_ns' % site)) elif 'injected_%s_end_time' % site in self.__slots__: return LIGOTimeGPS(getattr(self, 'injected_%s_end_time' % site ), getattr(self, 'injected_%s_end_time_ns' % site)) else: raise AttributeError, "could not find an injected_%s_start_time nor an injected_%s_end_time" %(site,site)
def get_recovered_gps_time(self): if 'recovered_start_time' in self.__slots__: return LIGOTimeGPS(self.recovered_start_time, self.recovered_start_time_ns) elif 'recovered_end_time' in self.__slots__: return LIGOTimeGPS(self.recovered_end_time, self.recovered_end_time_ns) else: raise AttributeError, "could not find a recovered_start_time or recovered_end_time"
def get_delta_t_rss(pt, coinc, reference_frequency=None): """ returns the rss timing error for a particular location in the sky (longitude,latitude) """ latitude, longitude = pt earth_center = (0.0, 0.0, 0.0) tref = {} tgeo = {} for ifo in coinc.ifo_list: if reference_frequency: tFromRefFreq = get_signal_duration(ifo, coinc, reference_frequency) tref[ifo] = LIGOTimeGPS(int(tFromRefFreq), 1.e9 * (tFromRefFreq - int(tFromRefFreq))) else: tref[ifo] = 0.0 #compute the geocentric time from each trigger tgeo[ifo] = coinc.gps[ifo] - tref[ifo] - \ LIGOTimeGPS(0,1.0e9*date.XLALArrivalTimeDiff(detector_locations[ifo],\ earth_center,longitude,latitude,coinc.gps[ifo])) #compute differences in these geocentric times time = {} delta_t_rms = 0.0 for ifos in coinc.ifo_coincs: time[ifos[0] + ifos[1]] = float(tgeo[ifos[0]] - tgeo[ifos[1]]) delta_t_rms += time[ifos[0] + ifos[1]] * time[ifos[0] + ifos[1]] return sqrt(delta_t_rms)
def test__div__(self): self.assertEqual(LIGOTimeGPS(10), LIGOTimeGPS(20) / 2) self.assertEqual(LIGOTimeGPS(10), LIGOTimeGPS(5) / 0.5) self.assertEqual(LIGOTimeGPS(333333333, 333333333), LIGOTimeGPS(1000000000) / 3) self.assertEqual(LIGOTimeGPS(666666666, 666666667), LIGOTimeGPS(2000000000) / 3)
def InspiralNearCoincCompare(sim, inspiral): """ Return False if the peak time of the sim is within 9 seconds of the inspiral event. """ return SnglInspiralUtils.CompareSnglInspiral(sim, inspiral, twindow=LIGOTimeGPS(9))
def timeDelay(gpsTime, rightAscension, declination, unit, det1, det2): """ timeDelay( gpsTime, rightAscension, declination, unit, det1, det2 ) Calculates the time delay in seconds between the detectors 'det1' and 'det2' (e.g. 'H1') for a sky location at (rightAscension and declination) which must be given in certain units ('radians' or 'degree'). The time is passes as GPS time. A positive time delay means the GW arrives first at 'det2', then at 'det1'. Example: antenna.timeDelay( 877320548.000, 355.084,31.757, 'degree','H1','L1') 0.0011604683260994519 Given these values, the signal arrives first at detector L1, and 1.16 ms later at H2 """ # check the input arguments if unit == 'radians': ra_rad = rightAscension de_rad = declination elif unit == 'degree': ra_rad = rightAscension / 180.0 * pi de_rad = declination / 180.0 * pi else: raise ValueError, "Unknown unit %s" % unit # check input values if ra_rad < 0.0 or ra_rad > 2 * pi: raise ValueError, "ERROR. right ascension=%f "\ "not within reasonable range."\ % (rightAscension) if de_rad < -pi or de_rad > pi: raise ValueError, "ERROR. declination=%f not within reasonable range."\ % (declination) if det1 == det2: return 0.0 gps = LIGOTimeGPS(gpsTime) # create detector-name map detMap = { 'H1': 'LHO_4k', 'H2': 'LHO_2k', 'L1': 'LLO_4k', 'G1': 'GEO_600', 'V1': 'VIRGO', 'T1': 'TAMA_300' } x1 = inject.cached_detector[detMap[det1]].location x2 = inject.cached_detector[detMap[det2]].location timedelay = date.XLALArrivalTimeDiff(list(x1), list(x2), ra_rad, de_rad, gps) return timedelay
def get_coincs_from_coinctable(self, files): """ read data from coinc tables (xml format) FIXME: currently assumes one coinc per file!!! """ for file in files: coinc = CoincData() xmldoc = utils.load_filename(file) sngltab = tab.get_table(xmldoc, lsctables.SnglInspiralTable.tableName) coinc.set_snr(dict((row.ifo, row.snr) for row in sngltab)) coinc.set_gps( dict((row.ifo, LIGOTimeGPS(row.get_end())) for row in sngltab)) #FIXME: this is put in place to deal with eff_distance = 0 # needs to be fixed upstream in the pipeline effDs = list((row.ifo, row.eff_distance) for row in sngltab) for eD in effDs: if eD[1] == 0.: effDs.append((eD[0], 1.)) effDs.remove(eD) coinc.set_effDs(dict(effDs)) # coinc.set_effDs(dict((row.ifo,row.eff_distance) for row in sngltab)) coinc.set_masses(dict((row.ifo, row.mass1) for row in sngltab), \ dict((row.ifo, row.mass2) for row in sngltab)) ctab = tab.get_table(xmldoc, lsctables.CoincInspiralTable.tableName) #FIXME: ignoring H2 for now, but should be dealt in a better way allifos = list(ctab[0].get_ifos()) try: allifos.remove('H2') except ValueError: pass coinc.set_ifos(allifos) if ctab[0].false_alarm_rate is not None: coinc.set_FAR(ctab[0].false_alarm_rate) try: simtab = tab.get_table(xmldoc, lsctables.SimInspiralTable.tableName) row = siminsptab[0] effDs_inj = {} for ifo in coinc.ifo_list: if ifo == 'H1': effDs_inj[ifo] = row.eff_dist_h elif ifo == 'L1': effDs_inj[ifo] = row.eff_dist_l elif ifo == 'V1': effDs_inj[ifo] = row.eff_dist_v dist_inj = row.distance coinc.set_inj_params(row.latitude,row.longitude,row.mass1,row.mass2, \ dist_inj,effDs_inj) coinc.is_injection = True #FIXME: name the exception! except: pass self.append(coinc)
def CompareMultiInspiral(a, b, twindow=LIGOTimeGPS(0)): """ Returns 0 if a and b are less than twindow appart. """ tdiff = abs(a.get_end() - b.get_end()) if tdiff < twindow: return 0 else: return cmp(a.get_end(), b.get_end())
def test__init__(self): correct = LIGOTimeGPS(100, 500000000) tests = [ (100.5, ), (100.500000000, ), (100.50000000000000000000000, ), ("100.5", ), ("100.500000000", ), ("100.50000000000000000000000", ), (0, 100500000000), (99, 1500000000), (-10, 110500000000), ] for num, test in enumerate(tests): try: self.assertEqual(correct, LIGOTimeGPS(*test)) except AssertionError, e: raise AssertionError, "Test %d failed: " % (num) + str(e)
def set_dt(self, dt): """ If an event's end time differs by more than this many seconds from the end time of another event then it is *impossible* for them to be coincident. """ # add 1% for safety, and pre-convert to LIGOTimeGPS to # avoid doing type conversion in loops self.dt = LIGOTimeGPS(dt * 1.01)
def get_gps_times( self ): """ Return a dictionary of the GPS times associated with each trigger in the coincidence. The time is stored in LIGOTimeGPS format. """ gpstimes={} for ifo in ifos: if hasattr(self,ifo): gpstimes[ifo]= LIGOTimeGPS(getattr(self, ifo).end_time, getattr(self, ifo).end_time_ns) return gpstimes
def cmp_sngl_sim(sim, sngl, get_sim_time, get_sngl_time, twindow=LIGOTimeGPS(9)): tdiff = abs(get_sngl_time(sngl) - get_sim_time(sim)) if tdiff < twindow: return 0 else: return cmp(get_sngl_time(sngl), get_sim_time(sim))
def get_time_delay(self, ifo1, ifo2, gpstime): """ Return the time delay for this SkyPosition between arrival at ifo1 relative to ifo2, for the given gpstime. """ det1 = inject.cached_detector.get(inject.prefix_to_name[ifo1]) det2 = inject.cached_detector.get(inject.prefix_to_name[ifo2]) return date.XLALArrivalTimeDiff(det1.location, det2.location,\ self.longitude, self.latitude,\ LIGOTimeGPS(gpstime))
def ISOTimeDelayLine(ifos, ra, dec, gpstime=None, n=3): """ Returns the n-point SkyPositionTable describing a line of constant time delay through the given ra and dec. for the given 2-tuple ifos. """ if gpstime: gpstime = LIGOTimeGPS(gpstime) p = SkyPosition() p.longitude = ra p.latitude = dec p.system = 'equatorial' p.probability = None p.solid_angle = None if gpstime: p = EquatorialToGeographic(p, gpstime) cart = SphericalToCartesian(p) # get baseline detectors = [inject.cached_detector.get(inject.prefix_to_name[ifo])\ for ifo in ifos] baseline = detectors[0].location - detectors[1].location baseline = baseline / np.linalg.norm(baseline) # get angle to baseline angle = np.arccos(np.dot(cart, baseline)) # get evenly spaced ring over north pole longitudes = np.linspace(0, lal.TWOPI, n, endpoint=False) latitudes = [lal.PI_2 - angle] * len(longitudes) # get axis and angle of rotation north = np.array([0, 0, 1]) axis = np.cross(north, baseline) axis = axis / np.linalg.norm(axis) angle = np.arccos(np.dot(north, baseline)) R = _rotation(axis, angle) # construct sky table iso = SkyPositionTable() for lon, lat in zip(longitudes, latitudes): e = SkyPosition() e.longitude = lon e.latitude = lat e.probability = None e.solid_angle = None e.system = 'geographic' e.normalize() e = e.rotate(R) if gpstime: e = GeographicToEquatorial(e, gpstime) iso.append(e) return iso
def get_coincs_from_coire(self, files, stat='snr'): """ uses CoincInspiralUtils to get data from old-style (coire'd) coincs """ coincTrigs = CoincInspiralUtils.coincInspiralTable() inspTrigs = SnglInspiralUtils.ReadSnglInspiralFromFiles(files, \ mangle_event_id = True,verbose=None) statistic = CoincInspiralUtils.coincStatistic(stat, None, None) coincTrigs = CoincInspiralUtils.coincInspiralTable( inspTrigs, statistic) try: inspInj = SimInspiralUtils.ReadSimInspiralFromFiles(files) coincTrigs.add_sim_inspirals(inspInj) #FIXME: name the exception! except: pass #now extract the relevant information into CoincData objects for ctrig in coincTrigs: coinc = CoincData() coinc.set_ifos(ctrig.get_ifos()[1]) coinc.set_gps( dict( (trig.ifo, LIGOTimeGPS(trig.get_end())) for trig in ctrig)) coinc.set_snr( dict((trig.ifo, getattr(ctrig, trig.ifo).snr) for trig in ctrig)) coinc.set_effDs( dict((trig.ifo, getattr(ctrig, trig.ifo).eff_distance) for trig in ctrig)) coinc.set_masses(dict((trig.ifo,getattr(ctrig,trig.ifo).mass1) for trig in ctrig), \ dict((trig.ifo,getattr(ctrig,trig.ifo).mass2) for trig in ctrig)) try: effDs_inj = {} for ifo in coinc.ifo_list: if ifo == 'H1': effDs_inj[ifo] = getattr(ctrig, 'sim').eff_dist_h elif ifo == 'L1': effDs_inj[ifo] = getattr(ctrig, 'sim').eff_dist_l elif ifo == 'V1': effDs_inj[ifo] = getattr(ctrig, 'sim').eff_dist_v dist_inj = getattr(ctrig, 'sim').distance coinc.set_inj_params(getattr(ctrig,'sim').latitude,getattr(ctrig,'sim').longitude, \ getattr(ctrig,'sim').mass1,getattr(ctrig,'sim').mass2,dist_inj,effDs_inj) coinc.is_injection = True #FIXME: name the exception! except: pass self.append(coinc)
def parse_COMPLEX16FrequencySeries(elem): t, = elem.getElementsByTagName(ligolw.Time.tagName) a, = elem.getElementsByTagName(ligolw.Array.tagName) dims = a.getElementsByTagName(ligolw.Dim.tagName) f0 = ligolw_param.get_param(elem, u"f0") return COMPLEX16FrequencySeries( name = a.Name, # FIXME: remove type cast when epoch can be a swig LIGOTimeGPS epoch = LIGOTimeGPS(str(t.pcdata)), f0 = f0.pcdata * float(LALUnit(f0.Unit) / LALUnit("s^-1")), deltaF = dims[0].Scale * float(LALUnit(dims[0].Unit) / LALUnit("s^-1")), sampleUnits = LALUnit(a.Unit), data = a.array[1] + 1j * a.array[2] )
def parseTimeDelayDegeneracy(self, ifos, gpstime=lal.GPSTimeNow(),\ dt=0.0005): # get detectors detectors = [inject.cached_detector.get(inject.prefix_to_name[ifo])\ for ifo in ifos] timeDelays = [] degenerate = [] new = table.new_from_template(self) for n, row in enumerate(self): # get all time delays for this point timeDelays.append([]) for i in xrange(len(ifos)): for j in xrange(i + 1, len(ifos)): timeDelays[n].append(date.XLALArrivalTimeDiff(\ detectors[i].location,\ detectors[j].location,\ row.longitude,\ row.latitude,\ LIGOTimeGPS(gpstime))) # skip the first point if n == 0: degenerate.append(False) new.append(row) continue else: degenerate.append(True) # test this point against all others for i in xrange(0, n): # if check point is degenerate, skip if degenerate[i]: continue # check each time delay individually for j in xrange(0, len(timeDelays[n])): # if this time delay is non-degenerate the point is valid if np.fabs(timeDelays[i][j] - timeDelays[n][j]) >= dt: degenerate[n] = False break else: degenerate[n] = True if degenerate[n]: break if not degenerate[n]: new.append(row) return new
def MaxTimeDelayLine3(ifo1, ifo2, ra, dec, gpstime=None, n=3): """ Alternative implementation of MaxTimeDelayLine. """ if gpstime: gpstime = LIGOTimeGPS(gpstime) p = SkyPosition() p.longitude = ra p.latitude = dec p.system = 'equatorial' p.probability = None p.solid_angle = None if gpstime: p = EquatorialToGeographic(p, gpstime) cart = SphericalToCartesian(p) # get baseline detectors = [inject.cached_detector.get(inject.prefix_to_name[ifo])\ for ifo in [ifo1,ifo2]] baseline = detectors[0].location - detectors[1].location baseline = baseline / np.linalg.norm(baseline) # get angular spacing dtheta = lal.TWOPI / n # get axis and angle of rotation north = np.array([0, 0, 1]) axis = np.cross(cart, baseline) axis = axis / np.linalg.norm(axis) R = _rotation(axis, dtheta) # set up list l = SkyPositionTable() # append central point l.append(p) for i in xrange(1, n): l.append(l[i - 1].rotate(R)) if gpstime: for i, p in enumerate(l): l[i] = GeographicToEquatorial(p, gpstime) return l
def get_sitelocaltime_from_gps(ifo, gpstime): # get the utc time in datetime.datetime format utctime = XLALGPSToUTC(LIGOTimeGPS(gpstime, 0)) utctime = datetime.datetime(utctime[0],utctime[1],utctime[2],utctime[3],utctime[4],utctime[5],utctime[6]) # figure out if daylight savings time was on or not dst_start, dst_end = get_dst_start_end(ifo, utctime.year) # figure out the appropriate time offset if "H" in ifo: toffset = datetime.timedelta(hours=-7) elif "L" in ifo: toffset = datetime.timedelta(hours=-5) elif ("V" in ifo or "G" in ifo): toffset = datetime.timedelta(hours=+2) # apply the dst time offset to see if daylight savings was on; if not, adjust the toffset if not (utctime + toffset >= dst_start and utctime + toffset < dst_end): toffset = toffset + datetime.timedelta(hours=-1) return utctime + toffset
def format_end_time_in_utc(gps_sec): return time.strftime("%a %d %b %Y %H:%M:%S", XLALGPSToUTC(LIGOTimeGPS(gps_sec, 0)))
def is_in_on_time(gps_time, gps_time_ns): return LIGOTimeGPS(gps_time, gps_time_ns) in on_times
def get_gps(self): return LIGOTimeGPS(self.gps, self.gps_ns)
def __init__(self, xmldoc, bbdef, sbdef, scedef, scndef, process, end_time_bisect_window): # # store the process row # self.process = process # # locate the sngl_inspiral and sim_inspiral tables # self.snglinspiraltable = lsctables.SnglInspiralTable.get_table(xmldoc) self.siminspiraltable = lsctables.SimInspiralTable.get_table(xmldoc) # # get the offset vectors from the document # self.offsetvectors = lsctables.TimeSlideTable.get_table( xmldoc).as_dict() # # get out segment lists for programs that generated # triggers (currently only used for time_slide vector # construction) # seglists = lsctables.SearchSummaryTable.get_table( xmldoc).get_out_segmentlistdict( set(self.snglinspiraltable.getColumnByName( "process_id"))).coalesce() # # construct the zero-lag time slide needed to cover the # instruments listed in all the triggers, then determine # its ID (or create it if needed) # # FIXME: in the future, the sim_inspiral table should # indicate time slide at which the injection was done # self.tisi_id = ligolw_time_slide.get_time_slide_id(xmldoc, {}.fromkeys( seglists, 0.0), create_new=process) # # get coinc_definer row for sim_inspiral <--> sngl_inspiral # coincs; this creates a coinc_definer table if the # document doesn't have one # self.sb_coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, sbdef.search, sbdef.search_coinc_type, create_new=True, description=sbdef.description) # # get coinc_def_id's for sngl_inspiral <--> sngl_inspiral, and # both kinds of sim_inspiral <--> coinc_event coincs. set all # to None if this document does not contain any sngl_inspiral # <--> sngl_inspiral coincs. # try: ii_coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, bbdef.search, bbdef.search_coinc_type, create_new=False) except KeyError: ii_coinc_def_id = None self.sce_coinc_def_id = None self.scn_coinc_def_id = None else: self.sce_coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, scedef.search, scedef.search_coinc_type, create_new=True, description=scedef.description) self.scn_coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, scndef.search, scndef.search_coinc_type, create_new=True, description=scndef.description) # # get coinc table, create one if needed # try: self.coinctable = lsctables.CoincTable.get_table(xmldoc) except ValueError: self.coinctable = lsctables.New(lsctables.CoincTable) xmldoc.childNodes[0].appendChild(self.coinctable) self.coinctable.sync_next_id() # # get coinc_map table, create one if needed # try: self.coincmaptable = lsctables.CoincMapTable.get_table(xmldoc) except ValueError: self.coincmaptable = lsctables.New(lsctables.CoincMapTable) xmldoc.childNodes[0].appendChild(self.coincmaptable) # # index the document # # FIXME: inspiral<-->inspiral coincs should be organized by time # slide ID, but since injections are only done at zero lag # for now this is ignored. # # index the sngl_inspiral table index = dict((row.event_id, row) for row in self.snglinspiraltable) # find IDs of inspiral<-->inspiral coincs self.sngls = dict((row.coinc_event_id, []) for row in self.coinctable if row.coinc_def_id == ii_coinc_def_id) # construct event list for each inspiral<-->inspiral coinc for row in self.coincmaptable: try: self.sngls[row.coinc_event_id].append(index[row.event_id]) except KeyError: pass del index # construct a sngl-->coincs look-up table self.coincs = dict((event.event_id, set()) for events in self.sngls.values() for event in events) for row in self.coincmaptable: if row.event_id in self.coincs and row.coinc_event_id in self.sngls: self.coincs[row.event_id].add(row.coinc_event_id) # create a coinc_event_id to offset vector look-up table self.coincoffsets = dict( (row.coinc_event_id, self.offsetvectors[row.time_slide_id]) for row in self.coinctable if row.coinc_def_id == ii_coinc_def_id) # # sort sngl_inspiral table by end time, and sort the coincs # list by the end time of the first (earliest) event in # each coinc (recall that the event tuple for each coinc # has been time-ordered) # self.snglinspiraltable.sort(lambda a, b: cmp(a.end_time, b.end_time) or cmp(a.end_time_ns, b.end_time_ns)) # # set the window for inspirals_near_endtime(). this window # is the amount of time such that if an injection's end # time and a inspiral event's end time differ by more than # this it is *impossible* for them to match one another. # self.end_time_bisect_window = LIGOTimeGPS(end_time_bisect_window)
def get_start(self): return LIGOTimeGPS(self.start_time, self.start_time_ns)
def ThreeSiteSkyGrid(ifos, gpstime, dt=0.0005, tiling='square', sky='half'): """ Generates a SkyPositionTable for a three-site all-sky grid, covering either a hemisphere (sky='half') or full sphere (sky='full'), using either 'square' or 'hexagonal tiling. """ # remove duplicate site references pop = [] for i, ifo in enumerate(ifos): if i == 0: continue site = ifo[0] if site in [x[0] for x in ifos[0:i]]: sys.stderr.write("Duplicate site reference, ignoring %s.\n" % ifo) pop.append(i) for p in pop[::-1]: ifos.pop(p) assert len(ifos) == 3 detectors = [] T = [] baseline = [] # load detectors for i, ifo in enumerate(ifos): detectors.append(inject.cached_detector.get( inject.prefix_to_name[ifo])) # get light travel time and baseline for other detectors to first if i >= 1: T.append(inject.light_travel_time(ifos[0], ifos[i])) baseline.append(detectors[i].location - detectors[0].location) baseline[i - 1] /= np.linalg.norm(baseline[i - 1]) # get angle between baselines angle = np.arccos(np.dot(baseline[0], baseline[1])) # # construct tiling vectors # tiling = tiling.lower() t = np.zeros(len(baseline)) tdgrid = [] # square grid dx = np.array([1, 0]) dy = np.array([0, 1]) nx = int(np.floor(T[0] / dt)) ny = int(np.floor(T[1] / dt)) # hexagonal grid if tiling == 'square': dm = dx dn = dy nm = nx nn = ny x = np.linspace(-nx, nx, 2 * nx + 1) y = np.linspace(-ny, ny, 2 * ny + 1) grid = np.array([[i, j] for i in x for j in y]) # hexagonal grid elif re.match('hex', tiling): dm = (2 * dx + dy) dn = (-dx + dy) dx = dm - dn # tile grid so that origin gets tiled grid = [] orig = np.array([0, 0]) # find bottom left point on grid while orig[1] >= -ny: orig -= dn # loop over y for y in xrange(-ny, ny + 1): orig[0] = orig[0] % dx[0] # work out minimal x value minx = -nx while minx % 3 != orig[0]: minx += 1 # tile x x = np.arange(minx, nx + 1, dx[0]) # append to grid grid.extend([[i, y] for i in x]) orig += dn orig[0] = orig[0] % dx[0] grid = np.asarray(grid) # # Following Rabaste, Chassande-Motin, Piran (2009), construct an ellipse # of physical values in 2D time-delay space for 3 detectors # # # (theta, phi) coordinate system is as follows: # detector 1 is origin # z-axis joins positively to detector 2 # x-axis is orthogonal to z-axis in plane joining D1, D2, and D3 # y-axis forms a right-handed coordinate system # # so need to rotate from Rabaste network coordinates into # earth-fixed coordinates at the end # set z-axis in Rabaste frame zaxis = baseline[0] # work out y-axis in Rabaste frame yaxis = np.cross(zaxis, baseline[1]) yaxis /= np.linalg.norm(yaxis) # work out x-axis in Rabaste frame xaxis = np.cross(yaxis, zaxis) xaxis /= np.linalg.norm(xaxis) # work out lines of nodes north = np.array([0, 0, 1]) lineofnodes = np.cross(baseline[0], north) lineofnodes /= np.linalg.norm(lineofnodes) # work out Euler angles alpha = np.arccos(np.dot(xaxis, lineofnodes)) beta = np.arccos(np.dot(baseline[0], north)) gamma = np.arccos(np.dot(lineofnodes, [1, 0, 0])) # construct rotation R = _rotation_euler(alpha, beta, gamma) # # construct sky position table # l = SkyPositionTable() # loop over time-delay between D1 and D2 k = 0 for i in grid: t = dt * i # construct coefficients of elliptical equation in quadratic form A = -T[1] / T[0] * t[0] * np.cos(angle) B = T[1]**2 * ((t[0] / T[0])**2 - np.sin(angle)**2) # test condition for inside ellipse and place point condition = t[1]**2 + 2 * A * t[1] + B if condition <= 0: ntheta = np.arccos(-t[0] / T[0]) nphi = np.arccos(-(T[0]*t[1]-T[1]*t[0]*np.cos(angle))/\ (T[1]*np.sqrt(T[0]**2-t[0]**2)*np.sin(angle))) p = SkyPosition() p.system = 'geographic' p.longitude = nphi p.latitude = lal.PI_2 - ntheta p.probability = None p.solid_angle = None p.normalize() p = p.rotate(R) p = GeographicToEquatorial(p, LIGOTimeGPS(gpstime)) l.append(p) if sky == 'full': p2 = SkyPosition() p2.longitude = p.longitude p2.latitude = p.latitude + lal.PI p2.system = 'equatorial' p2.normalize() l.append(p2) return l
def TwoSiteSkyGrid(ifos, gpstime, dt=0.0005, sky='half', point=None): """ Generates a SkyPositionTable for a two-site all-sky grid, covering either a hemisphere (sky='half') or full sphere (sky='full'). The grid can be forced to pass through the given SkyPosition point if required. """ # remove duplicate site references ifos = parse_sites(ifos) assert len(ifos) == 2, "More than two sites in given list of detectors" # get detectors detectors = [inject.cached_detector.get(inject.prefix_to_name[ifo])\ for ifo in ifos] # get light travel time ltt = inject.light_travel_time(ifos[0], ifos[1]) # get number of points max = int(np.floor(ltt / dt)) # get baseline baseline = detectors[1].location - detectors[0].location baseline /= np.linalg.norm(baseline) # # construct rotation # # xaxis points overhead of detector 1 or given point # zaxis is baseline, or something else if point: xaxis = SphericalToCartesian(point) xaxis /= np.linalg.norm(xaxis) zaxis = np.cross(xaxis, baseline) zaxis /= np.linalg.norm(zaxis) else: xaxis = detectors[0].location xaxis /= np.linalg.norm(xaxis) zaxis = baseline yaxis = np.cross(zaxis, xaxis) yaxis /= np.linalg.norm(yaxis) yaxis = np.cross(xaxis, zaxis) yaxis /= np.linalg.norm(yaxis) # construct Euler rotation lineofnodes = np.cross([0, 0, 1], zaxis) lineofnodes /= np.linalg.norm(lineofnodes) # work out Euler angles alpha = np.arccos(np.dot([1, 0, 0], lineofnodes)) beta = np.arccos(np.dot([0, 0, 1], zaxis)) gamma = np.arccos(np.dot(lineofnodes, xaxis)) # get rotation R = _rotation_euler(alpha, beta, gamma) # construct sky table l = SkyPositionTable() if sky == 'half': longs = [0] elif sky == 'full': longs = [0, lal.PI] else: raise AttributeError("Sky type \"%s\" not recognised, please use " "'half' or 'full'" % sky) for long in longs: for i in xrange(-max, max + 1): # get time-delay t = i * dt # if time-delay greater that light travel time, skip if abs(t) >= ltt: continue # construct object e = SkyPosition() e.system = 'geographic' # project time-delay onto prime meridian e.longitude = long e.latitude = lal.PI_2 - np.arccos(-t / ltt) e.probability = None e.solid_angle = None e.normalize() e = e.rotate(R) e = GeographicToEquatorial(e, LIGOTimeGPS(gpstime)) if e not in l: l.append(e) return l
def SkyPatch(ifos, ra, dec, radius, gpstime, dt=0.0005, sigma=1.65,\ grid='circular'): """ Returns a SkyPositionTable of circular rings emanating from a given central ra and dec. out to the maximal radius. """ # form centre point p = SkyPosition() p.longitude = ra p.latitude = dec # get detectors ifos.sort() detectors = [] for ifo in ifos: if ifo not in inject.prefix_to_name.keys(): raise ValueError("Interferometer '%s' not recognised." % ifo) detectors.append(inject.cached_detector.get(\ inject.prefix_to_name[ifo])) alpha = 0 for i in xrange(len(ifos)): for j in xrange(i + 1, len(ifos)): # get opening angle baseline = date.XLALArrivalTimeDiff(detectors[i].location,\ detectors[j].location,\ ra, dec, LIGOTimeGPS(gpstime)) ltt = inject.light_travel_time(ifos[i], ifos[j]) angle = np.arccos(baseline / ltt) # get window lmin = angle - radius lmax = angle + radius if lmin < lal.PI_2 and lmax > lal.PI_2: l = lal.PI_2 elif np.fabs(lal.PI_2-lmin) <\ np.fabs(lal.PI_2-lmax): l = lmin else: l = lmax # get alpha dalpha = ltt * np.sin(l) if dalpha > alpha: alpha = dalpha # get angular resolution angRes = 2 * dt / alpha # generate grid if grid.lower() == 'circular': grid = CircularGrid(angRes, radius) else: raise RuntimeError("Must use grid='circular', others not coded yet") # # Need to rotate grid onto (ra, dec) # # calculate opening angle from north pole north = [0, 0, 1] angle = np.arccos(np.dot(north, SphericalToCartesian(p))) #angle = north.opening_angle(p) # get rotation axis axis = np.cross(north, SphericalToCartesian(p)) axis = axis / np.linalg.norm(axis) # rotate grid R = _rotation(axis, angle) grid = grid.rotate(R) # # calculate probability density function # # assume Fisher distribution in angle from centre kappa = (0.66 * radius / sigma)**(-2) # compute probability for p in grid: overlap = np.cos(p.opening_angle(grid[0])) p.probability = np.exp(kappa * (overlap - 1)) probs = [p.probability for p in grid] for p in grid: p.probability = p.probability / max(probs) return grid
def frominjectionfile(file, type, ifo=None, start=None, end=None): """ Read generic injection file object file containing injections of the given type string. Returns an 'Sim' lsctable of the corresponding type. Arguments: file : file object type : [ "inspiral" | "burst" | "ringdown" ] Keyword arguments: ifo : [ "G1" | "H1" | "H2" | "L1" | "V1" ] """ # read type type = type.lower() # read injection xml xml = re.compile('(xml$|xml.gz$)') if re.search(xml,file.name): xmldoc,digest = utils.load_fileobj(file) injtable = table.get_table(xmldoc,'sim_%s:table' % (type)) # read injection txt else: cchar = re.compile('[#%<!()_\[\]{}:;\'\"]+') #== construct new Sim{Burst,Inspiral,Ringdown}Table injtable = lsctables.New(lsctables.__dict__['Sim%sTable' % (type.title())]) if type=='inspiral': columns = ['geocent_end_time.geocent_end_time_ns',\ 'h_end_time.h_end_time_ns',\ 'l_end_time.l_end_time_ns',\ 'v_end_time.v_end_time_ns',\ 'distance'] for line in file.readlines(): if re.match(cchar,line): continue # set up siminspiral object inj = lsctables.SimInspiral() # split data sep = re.compile('[\s,=]+') data = sep.split(line) # set attributes inj.geocent_end_time = int(data[0].split('.')[0]) inj.geocent_end_time_ns = int(data[0].split('.')[1]) inj.h_end_time = int(data[1].split('.')[0]) inj.h_end_time_ns = int(data[1].split('.')[1]) inj.l_end_time = int(data[2].split('.')[0]) inj.l_end_time_ns = int(data[2].split('.')[1]) inj.v_end_time = int(data[3].split('.')[0]) inj.v_end_time_ns = int(data[3].split('.')[1]) inj.distance = float(data[4]) injtable.append(inj) if type=='burst': if file.readlines()[0].startswith('filestart'): # if given parsed burst file file.seek(0) snrcol = { 'G1':23, 'H1':19, 'L1':21, 'V1':25 } for line in file.readlines(): inj = lsctables.SimBurst() # split data sep = re.compile('[\s,=]+') data = sep.split(line) # set attributes # gps time if 'burstgps' in data: idx = data.index('burstgps')+1 geocent = LIGOTimeGPS(data[idx]) inj.time_geocent_gps = geocent.seconds inj.time_geocent_gps_ns = geocent.nanoseconds else: continue #inj.waveform = data[4] #inj.waveform_number = int(data[5]) # frequency if 'freq' in data: idx = data.index('freq')+1 inj.frequency = float(data[idx]) else: continue # SNR a.k.a. amplitude if ifo and 'snr%s' % ifo in data: idx = data.index('snr%s' % ifo)+1 inj.amplitude = float(data[idx]) elif 'rmsSNR' in data: idx = data.index('rmsSNR')+1 inj.amplitude = float(data[idx]) else: continue if 'phi' in data: idx = data.index('phi' )+1 inj.ra = float(data[idx])*24/(2*math.pi) if 'theta' in data: idx = data.index('theta' )+1 inj.ra = 90-(float(data[idx])*180/math.pi) if ifo and 'hrss%s' % ifo in data: idx = data.index('hrss%s' % ifo)+1 inj.hrss = float(data[idx]) elif 'hrss' in data: idx = data.index('hrss')+1 inj.hrss = float(data[idx]) # extra columns to be added when I know how #inj.q = 0 #inj.q = float(data[11]) #h_delay = LIGOTimeGPS(data[41]) #inj.h_peak_time = inj.time_geocent_gps+h_delay.seconds #inj.h_peak_time_ns = inj.time_geocent_gps_ns+h_delay.nanoseconds #l_delay = LIGOTimeGPS(data[43]) #inj.l_peak_time = inj.time_geocent_gps+l_delay.seconds #inj.l_peak_time_ns = inj.time_geocent_gps_ns+l_delay.nanoseconds #v_delay = LIGOTimeGPS(data[43]) #inj.v_peak_time = inj.time_geocent_gps+v_delay.seconds #inj.v_peak_time_ns = inj.time_geocent_gps_ns+v_delay.nanoseconds injtable.append(inj) else: # if given parsed burst file file.seek(0) for line in file.readlines(): inj = lsctables.SimBurst() # split data sep = re.compile('[\s,]+') data = sep.split(line) # set attributes geocent = LIGOTimeGPS(data[0]) inj.time_geocent_gps = geocent.seconds inj.time_geocent_gps_ns = geocent.nanoseconds injtable.append(inj) injections = table.new_from_template(injtable) if not start: start = 0 if not end: end = 9999999999 span = segments.segmentlist([ segments.segment(start, end) ]) get_time = dqTriggerUtils.def_get_time(injections.tableName) injections.extend(inj for inj in injtable if get_time(inj) in span) return injections
def get_end(self): return LIGOTimeGPS(self.end_time, self.end_time_ns)
def get_daily_ihope_page(gpstime, pages_location = "https://ldas-jobs.ligo.caltech.edu/~cbc/ihope_daily"): utctime = XLALGPSToUTC(LIGOTimeGPS(gpstime, 0)) return "%s/%s/%s/" %(pages_location, time.strftime("%Y%m", utctime), time.strftime("%Y%m%d", utctime))