def _dePrecess(self, ra_in, dec_in, obs_metadata):
"""
Transform a set of RA, Dec pairs by subtracting out a rotation
which represents the effects of precession, nutation, and aberration.
Specifically:
Calculate the displacement between the boresite and the boresite
corrected for precession, nutation, and aberration (not refraction).
Convert boresite and corrected boresite to Cartesian coordinates.
Calculate the rotation matrix to go between those Cartesian vectors.
Convert [ra_in, dec_in] into Cartesian coordinates.
Apply the rotation vector to those Cartesian coordinates.
Convert back to ra, dec-like coordinates
@param [in] ra_in is a numpy array of RA in radians
@param [in] dec_in is a numpy array of Dec in radians
@param [in] obs_metadata is an ObservationMetaData
@param [out] ra_out is a numpy array of de-precessed RA in radians
@param [out] dec_out is a numpy array of de-precessed Dec in radians
"""
if len(ra_in) == 0:
return np.array([[], []])
# Calculate the rotation matrix to go from the precessed bore site
# to the ICRS bore site
xyz_bore = cartesianFromSpherical(np.array([obs_metadata._pointingRA]),
np.array([obs_metadata._pointingDec]))
precessedRA, precessedDec = _observedFromICRS(np.array([obs_metadata._pointingRA]),
np.array([obs_metadata._pointingDec]),
obs_metadata=obs_metadata, epoch=2000.0,
includeRefraction=False)
xyz_precessed = cartesianFromSpherical(precessedRA, precessedDec)
rotMat = rotationMatrixFromVectors(xyz_precessed[0], xyz_bore[0])
xyz_list = cartesianFromSpherical(ra_in, dec_in)
xyz_de_precessed = np.array([np.dot(rotMat, xx) for xx in xyz_list])
ra_deprecessed, dec_deprecessed = sphericalFromCartesian(xyz_de_precessed)
return np.array([ra_deprecessed, dec_deprecessed])
def _icrsFromPhoSim(self, raPhoSim, decPhoSim, obs_metadata):
"""
This method will convert from the 'deprecessed' coordinates expected by
PhoSim to ICRS coordinates
Parameters
----------
raPhoSim is the PhoSim RA-like coordinate (in radians)
decPhoSim is the PhoSim Dec-like coordinate (in radians)
obs_metadata is an ObservationMetaData characterizing the
telescope pointing
Returns
-------
raICRS in radians
decICRS in radians
"""
# Calculate the rotation matrix to go from the ICRS bore site to the
# precessed bore site
xyz_bore = cartesianFromSpherical(np.array([obs_metadata._pointingRA]),
np.array([obs_metadata._pointingDec]))
precessedRA, precessedDec = _observedFromICRS(np.array([obs_metadata._pointingRA]),
np.array([obs_metadata._pointingDec]),
obs_metadata=obs_metadata, epoch=2000.0,
includeRefraction=False)
xyz_precessed = cartesianFromSpherical(precessedRA, precessedDec)
rotMat = rotationMatrixFromVectors(xyz_bore[0], xyz_precessed[0])
# apply this rotation matrix to the PhoSim RA, Dec-like coordinates,
# transforming back to "Observed" RA and Dec
xyz_list = cartesianFromSpherical(raPhoSim, decPhoSim)
xyz_obs = np.array([np.dot(rotMat, xx) for xx in xyz_list])
ra_obs, dec_obs = sphericalFromCartesian(xyz_obs)
# convert to ICRS coordinates
return _icrsFromObserved(ra_obs, dec_obs, obs_metadata=obs_metadata,
epoch=2000.0, includeRefraction=False)
def testRotationMatrixFromVectors(self):
v1 = np.zeros((3), dtype=float)
v2 = np.zeros((3), dtype=float)
v3 = np.zeros((3), dtype=float)
v1[0] = -3.044619987218469825e-01
v2[0] = 5.982190522311925385e-01
v1[1] = -5.473550908956383854e-01
v2[1] = -5.573565912346714057e-01
v1[2] = 7.795545496018386755e-01
v2[2] = -5.757495946632366079e-01
output = utils.rotationMatrixFromVectors(v1, v2)
for i in range(3):
for j in range(3):
v3[i] += output[i][j]*v1[j]
for i in range(3):
self.assertAlmostEqual(v3[i], v2[i], 7)
v1 = np.array([1.0, 1.0, 1.0])
self.assertRaises(RuntimeError, utils.rotationMatrixFromVectors, v1, v2)
self.assertRaises(RuntimeError, utils.rotationMatrixFromVectors, v2, v1)
def __init__(self, ra0, dec0, ra1, dec1):
"""
Parameters
----------
ra0, dec0 are the coordinates of the original field
center in degrees
ra1, dec1 are the coordinates of the new field center
in degrees
The transform() method of this class operates by first
applying a rotation that carries the original field center
into the new field center. Points are then transformed into
a basis in which the unit vector defining the new field center
is the x-axis. A rotation about the x-axis is applied so that
a point that was due north of the original field center is still
due north of the field center at the new location. Finally,
points are transformed back into the original x,y,z bases.
"""
# find the rotation that carries the original field center
# to the new field center
xyz = cartesianFromSpherical(np.radians(ra0), np.radians(dec0))
xyz1 = cartesianFromSpherical(np.radians(ra1), np.radians(dec1))
if np.abs(1.0-np.dot(xyz, xyz1))<1.0e-10:
self._transformation = np.identity(3, dtype=float)
return
first_rotation = rotationMatrixFromVectors(xyz, xyz1)
# create a basis set in which the unit vector
# defining the new field center is the x axis
xx = np.dot(first_rotation, xyz)
rng = np.random.RandomState(99)
mag = np.NaN
while np.abs(mag)<1.0e-20 or np.isnan(mag):
random_vec = rng.random_sample(3)
comp = np.dot(random_vec, xx)
yy = random_vec - comp*xx
mag = np.sqrt((yy**2).sum())
yy /= mag
zz = np.cross(xx, yy)
to_self_bases = np.array([xx,
yy,
zz])
out_of_self_bases =to_self_bases.transpose()
# Take a point due north of the original field
# center. Apply first_rotation to carry it to
# the new field. Transform it to the [xx, yy, zz]
# bases and find the rotation about xx that will
# make it due north of the new field center.
# Finally, transform back to the original bases.
d_dec = 0.1
north = cartesianFromSpherical(np.radians(ra0),
np.radians(dec0+d_dec))
north = np.dot(first_rotation, north)
#print(np.degrees(sphericalFromCartesian(north)))
north_true = cartesianFromSpherical(np.radians(ra1),
np.radians(dec1+d_dec))
north = np.dot(to_self_bases, north)
north_true = np.dot(to_self_bases, north_true)
north = np.array([north[1], north[2]])
north /= np.sqrt((north**2).sum())
north_true = np.array([north_true[1], north_true[2]])
north_true /= np.sqrt((north_true**2).sum())
c = north_true[0]*north[0]+north_true[1]*north[1]
s = north[0]*north_true[1]-north[1]*north_true[0]
norm = np.sqrt(c*c+s*s)
c = c/norm
s = s/norm
nprime = np.array([c*north[0]-s*north[1],
s*north[0]+c*north[1]])
yz_rotation = np.array([[1.0, 0.0, 0.0],
[0.0, c, -s],
[0.0, s, c]])
second_rotation = np.dot(out_of_self_bases,
np.dot(yz_rotation,
to_self_bases))
self._transformation = np.dot(second_rotation,
first_rotation)
def __init__(self, ra0, dec0, ra1, dec1):
"""
Parameters
----------
ra0, dec0 are the coordinates of the original field
center in radians
ra1, dec1 are the coordinates of the new field center
in radians
The transform() method of this class operates by first
applying a rotation that carries the original field center
into the new field center. Points are then transformed into
a basis in which the unit vector defining the new field center
is the x-axis. A rotation about the x-axis is applied so that
a point that was due north of the original field center is still
due north of the field center at the new location. Finally,
points are transformed back into the original x,y,z bases.
"""
self._ra0 = ra0
self._dec0 = dec0
self._ra1 = ra1
self._dec1 = dec1
# find the rotation that carries the original field center
# to the new field center
xyz = cartesianFromSpherical(ra0, dec0)
xyz1 = cartesianFromSpherical(ra1, dec1)
if np.abs(1.0-np.dot(xyz, xyz1))<1.0e-10:
self._transformation = np.identity(3, dtype=float)
return
first_rotation = rotationMatrixFromVectors(xyz, xyz1)
# create a basis set in which the unit vector
# defining the new field center is the x axis
xx = np.dot(first_rotation, xyz)
rng = np.random.RandomState(99)
mag = np.NaN
while np.abs(mag)<1.0e-20 or np.isnan(mag):
random_vec = rng.random_sample(3)
comp = np.dot(random_vec, xx)
yy = random_vec - comp*xx
mag = np.sqrt((yy**2).sum())
yy /= mag
zz = np.cross(xx, yy)
to_self_bases = np.array([xx,
yy,
zz])
out_of_self_bases =to_self_bases.transpose()
# Take a point due north of the original field
# center. Apply first_rotation to carry it to
# the new field. Transform it to the [xx, yy, zz]
# bases and find the rotation about xx that will
# make it due north of the new field center.
# Finally, transform back to the original bases.
d_dec = np.radians(0.1)
north = cartesianFromSpherical(ra0,dec0+d_dec)
north = np.dot(first_rotation, north)
#print(np.degrees(sphericalFromCartesian(north)))
north_true = cartesianFromSpherical(ra1, dec1+d_dec)
north = np.dot(to_self_bases, north)
north_true = np.dot(to_self_bases, north_true)
north = np.array([north[1], north[2]])
north /= np.sqrt((north**2).sum())
north_true = np.array([north_true[1], north_true[2]])
north_true /= np.sqrt((north_true**2).sum())
c = north_true[0]*north[0]+north_true[1]*north[1]
s = north[0]*north_true[1]-north[1]*north_true[0]
norm = np.sqrt(c*c+s*s)
c = c/norm
s = s/norm
nprime = np.array([c*north[0]-s*north[1],
s*north[0]+c*north[1]])
yz_rotation = np.array([[1.0, 0.0, 0.0],
[0.0, c, -s],
[0.0, s, c]])
second_rotation = np.dot(out_of_self_bases,
np.dot(yz_rotation,
to_self_bases))
self._transformation = np.dot(second_rotation,
first_rotation)