def timeDelay(gpsTime, det1, det2):
"""
Computes the time delay between two detectors dependant on a theoretical signals sky orientation.
gpsTime is kept constant, however, right ascension and declination are random. Declination is
passed through arcsin function to remove over representation of signals in detectors blind spots.
A positive time delay means the GW arrives first at 'det2', then at 'det1'.
"""
ra_rad = np.random.uniform(0, 2 * pi) # right ascension in rads
de_rad = np.arcsin(np.random.uniform(-1, 1)) # declination
if det1 == det2:
return 0.0
gps = lal.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 = lal.ArrivalTimeDiff(list(x1), list(x2), ra_rad, de_rad, gps)
return timedelay
def time_delay_from_detector(self, other_detector, right_ascension,
declination, t_gps):
"""Return the time delay from the given to detector for a signal with
the given sky location; i.e. return `t1 - t2` where `t1` is the
arrival time in this detector and `t2` is the arrival time in the
other detector. Note that this would return the same value as
`time_delay_from_earth_center` if `other_detector` was geocentric.
Parameters
----------
other_detector : detector.Detector
A detector instance.
right_ascension : float
The right ascension (in rad) of the signal.
declination : float
The declination (in rad) of the signal.
t_gps : float
The GPS time (in s) of the signal.
Returns
-------
float
The arrival time difference between the detectors.
"""
return lal.ArrivalTimeDiff(self.location, other_detector.location,
float(right_ascension), float(declination),
float(t_gps))
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 = lal.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 = lal.ArrivalTimeDiff(list(x1), list(x2), ra_rad, de_rad, gps)
return timedelay
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 = cached_detector.get(prefix_to_name[ifo1])
det2 = cached_detector.get(prefix_to_name[ifo2])
return lal.ArrivalTimeDiff(det1.location, det2.location,\
self.longitude, self.latitude,\
lal.LIGOTimeGPS(gpstime))
def test_delay_from_detector(self):
ra, dec, time = self.ra[0:10], self.dec[0:10], self.time[0:10]
for d1 in self.d:
for d2 in self.d:
time1 = []
for ra1, dec1, tim1 in zip(ra, dec, time):
t1 = lal.ArrivalTimeDiff(d1.location, d2.location,
ra1, dec1, tim1)
time1.append(t1)
time1 = numpy.array(time1)
time2 = d1.time_delay_from_detector(d2, ra, dec, time)
self.assertLess(abs(time1 - time2).max(), 1e-3)
def parseTimeDelayDegeneracy(self, ifos, gpstime=lal.GPSTimeNow(),\
dt=0.0005):
# get detectors
detectors = [cached_detector.get(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(lal.ArrivalTimeDiff(\
detectors[i].location,\
detectors[j].location,\
row.longitude,\
row.latitude,\
lal.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 XLALTimeDelayFromEarthCenter(pos, ra, dec, gps): return lal.ArrivalTimeDiff(pos, (0.0, 0.0, 0.0), ra, dec, gps)
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 prefix_to_name.keys():
raise ValueError("Interferometer '%s' not recognised." % ifo)
detectors.append(cached_detector.get(\
prefix_to_name[ifo]))
alpha = 0
for i in xrange(len(ifos)):
for j in xrange(i + 1, len(ifos)):
# get opening angle
baseline = lal.ArrivalTimeDiff(detectors[i].location,\
detectors[j].location,\
ra, dec, lal.LIGOTimeGPS(gpstime))
ltt = float(
lal.LIGOTimeGPS(
0, lal.LightTravelTime(detectors[i], detectors[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