def test_rad(self):
nside = 64
hpids = np.arange(hp.nside2npix(nside))
ra, dec = utils._hpid2RaDec(nside, hpids)
mjd = 59852.
obs = utils.ObservationMetaData(mjd=mjd)
alt1, az1, pa1 = utils._altAzPaFromRaDec(ra, dec, obs)
alt2, az2 = utils._approx_RaDec2AltAz(ra, dec, obs.site.latitude_rad,
obs.site.longitude_rad, mjd)
# Check that the fast is similar to the more precice transform
tol = np.radians(2)
tol_mean = np.radians(1.)
separations = utils._angularSeparation(az1, alt1, az2, alt2)
self.assertLess(np.max(separations), tol)
self.assertLess(np.mean(separations), tol_mean)
# Check that the fast can nearly round-trip
ra_back, dec_back = utils._approx_altAz2RaDec(alt2, az2,
obs.site.latitude_rad,
obs.site.longitude_rad,
mjd)
separations = utils._angularSeparation(ra, dec, ra_back, dec_back)
self.assertLess(np.max(separations), tol)
self.assertLess(np.mean(separations), tol_mean)
def test_raDecAltAz_noRefraction_degVsRadians(self):
"""
Check that raDecFromAltAz and altAzPaFromRaDec are consistent in a degrees-versus-radians
sense when refraction is turned off
"""
rng = np.random.RandomState(34)
n_samples = 10
ra_in = rng.random_sample(n_samples)*360.0
dec_in = rng.random_sample(n_samples)*180.0 - 90.0
mjd = 43000.0
obs = utils.ObservationMetaData(mjd=mjd)
alt, az, pa = utils.altAzPaFromRaDec(ra_in, dec_in, obs, includeRefraction=False)
alt_rad, az_rad, pa_rad = utils._altAzPaFromRaDec(np.radians(ra_in),
np.radians(dec_in),
obs, includeRefraction=False)
distance = utils.haversine(az_rad, alt_rad,
np.radians(az), np.radians(alt))
self.assertLess(utils.arcsecFromRadians(distance).min(), 0.001)
np.testing.assert_array_almost_equal(pa, np.degrees(pa_rad), decimal=12)
ra, dec = utils.raDecFromAltAz(alt, az, obs, includeRefraction=False)
ra_rad, dec_rad = utils._raDecFromAltAz(alt_rad, az_rad, obs, includeRefraction=False)
distance = utils.haversine(ra_rad, dec_rad, np.radians(ra), np.radians(dec))
self.assertLess(utils.arcsecFromRadians(distance).min(), 0.001)
def testExceptions(self):
"""
Test to make sure that methods complain when incorrect data types are passed.
"""
obs = utils.ObservationMetaData(pointingRA=55.0, pointingDec=-72.0, mjd=53467.8)
raFloat = 1.1
raList = np.array([0.2, 0.3])
decFloat = 1.1
decList = np.array([0.2, 0.3])
self.assertRaises(RuntimeError, utils._altAzPaFromRaDec, raList, decFloat, obs)
self.assertRaises(RuntimeError, utils._altAzPaFromRaDec, raFloat, decList, obs)
utils._altAzPaFromRaDec(raFloat, decFloat, obs)
utils._altAzPaFromRaDec(raList, decList, obs)
self.assertRaises(RuntimeError, utils._raDecFromAltAz, raList, decFloat, obs)
self.assertRaises(RuntimeError, utils._raDecFromAltAz, raFloat, decList, obs)
utils._raDecFromAltAz(raFloat, decFloat, obs)
utils._raDecFromAltAz(raList, decList, obs)
self.assertRaises(RuntimeError, utils.altAzPaFromRaDec, raList, decFloat, obs)
self.assertRaises(RuntimeError, utils.altAzPaFromRaDec, raFloat, decList, obs)
utils.altAzPaFromRaDec(raFloat, decFloat, obs)
utils.altAzPaFromRaDec(raList, decList, obs)
self.assertRaises(RuntimeError, utils.raDecFromAltAz, raList, decFloat, obs)
self.assertRaises(RuntimeError, utils.raDecFromAltAz, raFloat, decList, obs)
utils.raDecFromAltAz(raFloat, decFloat, obs)
utils.raDecFromAltAz(raList, decList, obs)
def test_raDecFromAltAz_noref(self):
"""
test that raDecFromAltAz correctly inverts altAzPaFromRaDec, even when
refraction is turned off
"""
rng = np.random.RandomState(55)
n_samples = 10
n_batches = 10
for i_batch in range(n_batches):
d_sun = 0.0
while d_sun < 45.0: # because ICRS->Observed transformation breaks down close to the sun
alt_in = rng.random_sample(n_samples)*50.0 + 20.0
az_in = rng.random_sample(n_samples)*360.0
obs = utils.ObservationMetaData(mjd=43000.0)
ra_in, dec_in = utils.raDecFromAltAz(alt_in, az_in, obs=obs, includeRefraction=False)
d_sun = utils.distanceToSun(ra_in, dec_in, obs.mjd).min()
alt_out, az_out, pa_out = utils.altAzPaFromRaDec(ra_in, dec_in, obs=obs,
includeRefraction=False)
dd = utils.haversine(np.radians(alt_out), np.radians(az_out),
np.radians(alt_in), np.radians(az_in))
self.assertLess(utils.arcsecFromRadians(dd).max(), 0.01)
def test_altAzPaFromRaDec_no_refraction(self):
"""
Test that altAzPaFromRaDec gives a sane answer when you turn off
refraction.
"""
rng = np.random.RandomState(44)
n_samples = 10
n_batches = 10
for i_batch in range(n_batches):
# first, generate some sane RA, Dec values by generating sane
# Alt, Az values with refraction and converting them into
# RA, Dec
alt_sane = rng.random_sample(n_samples)*45.0 + 45.0
az_sane = rng.random_sample(n_samples)*360.0
mjd_input = rng.random_sample(n_samples)*10000.0 + 40000.0
mjd_list = utils.ModifiedJulianDate.get_list(TAI=mjd_input)
ra_sane = []
dec_sane = []
obs_sane = []
for alt, az, mjd in zip(alt_sane, az_sane, mjd_list):
obs = utils.ObservationMetaData(mjd=mjd)
ra, dec = utils.raDecFromAltAz(alt, az, obs)
ra_sane.append(ra)
dec_sane.append(dec)
obs_sane.append(obs)
# Now, loop over our refracted RA, Dec, Alt, Az values.
# Convert from RA, Dec to unrefracted Alt, Az. Then, apply refraction
# with our applyRefraction method. Check that the resulting refracted
# zenith distance is:
# 1) within 0.1 arcsec of the zenith distance of the already refracted
# alt value calculated above
#
# 2) closer to the zenith distance calculated above than to the
# unrefracted zenith distance
for ra, dec, obs, alt_ref, az_ref in \
zip(ra_sane, dec_sane, obs_sane, alt_sane, az_sane):
alt, az, pa = utils.altAzPaFromRaDec(ra, dec, obs,
includeRefraction = False)
tanz, tanz3 = utils.refractionCoefficients(site=obs.site)
refracted_zd = utils.applyRefraction(np.radians(90.0-alt), tanz, tanz3)
# Check that the two independently refracted zenith distances agree
# to within 0.1 arcsec
self.assertLess(np.abs(utils.arcsecFromRadians(refracted_zd) -
utils.arcsecFromRadians(np.radians(90.0-alt_ref))),
0.1)
# Check that the two refracted zenith distances are closer to each other
# than to the unrefracted zenith distance
self.assertLess(np.abs(np.degrees(refracted_zd)-(90.0-alt_ref)),
np.abs((90.0-alt_ref) - (90.0-alt)))
self.assertLess(np.abs(np.degrees(refracted_zd)-(90.0-alt_ref)),
np.abs(np.degrees(refracted_zd) - (90.0-alt)))
def _presliceFootprint(self, simData):
"""Loop over each pointing and find which sky points are observed """
# Now to make a list of lists for looking up the relevant observations at each slicepoint
self.sliceLookup = [[] for dummy in range(self.nslice)]
self.chipNames = [[] for dummy in range(self.nslice)]
# Make a kdtree for the _slicepoints_
# Using scipy 0.16 or later
self._buildTree(self.slicePoints['ra'],
self.slicePoints['dec'],
leafsize=self.leafsize)
# Loop over each unique pointing position
if self.latLonDeg:
lat = np.radians(simData[self.latCol])
lon = np.radians(simData[self.lonCol])
else:
lat = simData[self.latCol]
lon = simData[self.lonCol]
for ind, ra, dec, rotSkyPos, mjd in zip(np.arange(simData.size), lon,
lat,
simData[self.rotSkyPosColName],
simData[self.mjdColName]):
dx, dy, dz = simsUtils._xyz_from_ra_dec(ra, dec)
# Find healpixels inside the FoV
hpIndices = np.array(
self.opsimtree.query_ball_point((dx, dy, dz), self.rad))
if hpIndices.size > 0:
obs_metadata = simsUtils.ObservationMetaData(
pointingRA=np.degrees(ra),
pointingDec=np.degrees(dec),
rotSkyPos=np.degrees(rotSkyPos),
mjd=mjd)
chipNames = _chipNameFromRaDec(
self.slicePoints['ra'][hpIndices],
self.slicePoints['dec'][hpIndices],
epoch=self.epoch,
camera=self.camera,
obs_metadata=obs_metadata)
# If we are using only a subset of chips
if self.chipsToUse != 'all':
checkedChipNames = [
chipName in self.chipsToUse for chipName in chipNames
]
good = np.where(checkedChipNames)[0]
chipNames = chipNames[good]
hpIndices = hpIndices[good]
# Find the healpixels that fell on a chip for this pointing
good = np.where(chipNames != [None])[0]
hpOnChip = hpIndices[good]
for i, chipName in zip(hpOnChip, chipNames[good]):
self.sliceLookup[i].append(ind)
self.chipNames[i].append(chipName)
if self.verbose:
"Created lookup table after checking for chip gaps."
def controlAltAzFromRaDec(raRad_in, decRad_in, longRad, latRad, mjd):
"""
Converts RA and Dec to altitude and azimuth
@param [in] raRad is the RA in radians
(observed geocentric)
@param [in] decRad is the Dec in radians
(observed geocentric)
@param [in] longRad is the longitude of the observer in radians
(positive east of the prime meridian)
@param [in[ latRad is the latitude of the observer in radians
(positive north of the equator)
@param [in] mjd is the universal time expressed as an MJD
@param [out] altitude in radians
@param [out[ azimuth in radians
see: http://www.stargazing.net/kepler/altaz.html#twig04
"""
obs = utils.ObservationMetaData(mjd=utils.ModifiedJulianDate(UTC=mjd),
site=utils.Site(longitude=np.degrees(longRad),
latitude=np.degrees(latRad),
name='LSST'))
if hasattr(raRad_in, '__len__'):
raRad, decRad = utils._observedFromICRS(raRad_in, decRad_in, obs_metadata=obs,
epoch=2000.0, includeRefraction=True)
else:
raRad, decRad = utils._observedFromICRS(raRad_in, decRad_in,
obs_metadata=obs, epoch=2000.0, includeRefraction=True)
lst = utils.calcLmstLast(obs.mjd.UT1, longRad)
last = lst[1]
haRad = np.radians(last * 15.) - raRad
sinDec = np.sin(decRad)
cosLat = np.cos(latRad)
sinLat = np.sin(latRad)
sinAlt = sinDec*sinLat + np.cos(decRad)*cosLat*np.cos(haRad)
altRad = np.arcsin(sinAlt)
azRad = np.arccos((sinDec - sinAlt*sinLat) / (np.cos(altRad)*cosLat))
azRadOut = np.where(np.sin(haRad) >= 0.0, 2.0 * np.pi - azRad, azRad)
if isinstance(altRad, float):
return altRad, float(azRadOut)
return altRad, azRadOut
def testAltAzFromRaDec(self):
"""
Test conversion from RA, Dec to Alt, Az
"""
nSamples = 100
ra = self.rng.random_sample(nSamples)*2.0*np.pi
dec = (self.rng.random_sample(nSamples)-0.5)*np.pi
lon_rad = 1.467
lat_rad = -0.234
controlAlt, controlAz = controlAltAzFromRaDec(ra, dec,
lon_rad, lat_rad,
self.mjd)
obs = utils.ObservationMetaData(mjd=utils.ModifiedJulianDate(UTC=self.mjd),
site=utils.Site(longitude=np.degrees(lon_rad),
latitude=np.degrees(lat_rad),
name='LSST'))
# verify parallactic angle against an expression from
# http://www.astro.washington.edu/groups/APO/Mirror.Motions/Feb.2000.Image.Jumps/report.html#Image%20motion%20directions
#
ra_obs, dec_obs = utils._observedFromICRS(ra, dec, obs_metadata=obs, epoch=2000.0,
includeRefraction=True)
lmst, last = utils.calcLmstLast(obs.mjd.UT1, lon_rad)
hourAngle = np.radians(last * 15.0) - ra_obs
controlSinPa = np.sin(hourAngle) * np.cos(lat_rad) / np.cos(controlAlt)
testAlt, testAz, testPa = utils._altAzPaFromRaDec(ra, dec, obs)
distance = utils.arcsecFromRadians(utils.haversine(controlAz, controlAlt, testAz, testAlt))
self.assertLess(distance.max(), 0.0001)
self.assertLess(np.abs(np.sin(testPa) - controlSinPa).max(), self.tolerance)
# test non-vectorized version
for r, d in zip(ra, dec):
controlAlt, controlAz = controlAltAzFromRaDec(r, d, lon_rad, lat_rad, self.mjd)
testAlt, testAz, testPa = utils._altAzPaFromRaDec(r, d, obs)
lmst, last = utils.calcLmstLast(obs.mjd.UT1, lon_rad)
r_obs, dec_obs = utils._observedFromICRS(r, d, obs_metadata=obs,
epoch=2000.0, includeRefraction=True)
hourAngle = np.radians(last * 15.0) - r_obs
controlSinPa = np.sin(hourAngle) * np.cos(lat_rad) / np.cos(controlAlt)
distance = utils.arcsecFromRadians(utils.haversine(controlAz, controlAlt, testAz, testAlt))
self.assertLess(distance, 0.0001)
self.assertLess(np.abs(np.sin(testPa) - controlSinPa), self.tolerance)
def testAltAzRADecRoundTrip(self):
"""
Test that altAzPaFromRaDec and raDecFromAltAz really invert each other
"""
mjd = 58350.0
alt_in = []
az_in = []
for alt in np.arange(0.0, 90.0, 10.0):
for az in np.arange(0.0, 360.0, 10.0):
alt_in.append(alt)
az_in.append(az)
alt_in = np.array(alt_in)
az_in = np.array(az_in)
for lon in (0.0, 90.0, 135.0):
for lat in (60.0, 30.0, -60.0, -30.0):
obs = utils.ObservationMetaData(mjd=mjd,
site=utils.Site(longitude=lon, latitude=lat, name='LSST'))
ra_in, dec_in = utils.raDecFromAltAz(alt_in, az_in, obs)
self.assertIsInstance(ra_in, np.ndarray)
self.assertIsInstance(dec_in, np.ndarray)
self.assertFalse(np.isnan(ra_in).any(), msg='there were NaNs in ra_in')
self.assertFalse(np.isnan(dec_in).any(), msg='there were NaNs in dec_in')
# test that passing them in one at a time gives the same answer
for ix in range(len(alt_in)):
ra_f, dec_f = utils.raDecFromAltAz(alt_in[ix], az_in[ix], obs)
self.assertIsInstance(ra_f, np.float)
self.assertIsInstance(dec_f, np.float)
self.assertAlmostEqual(ra_f, ra_in[ix], 12)
self.assertAlmostEqual(dec_f, dec_in[ix], 12)
alt_out, az_out, pa_out = utils.altAzPaFromRaDec(ra_in, dec_in, obs)
self.assertFalse(np.isnan(pa_out).any(), msg='there were NaNs in pa_out')
for alt_c, az_c, alt_t, az_t in \
zip(np.radians(alt_in), np.radians(az_in), np.radians(alt_out), np.radians(az_out)):
distance = utils.arcsecFromRadians(utils.haversine(az_c, alt_c, az_t, alt_t))
self.assertLess(distance, 0.2)
with h5py.File(obs_fname, 'r') as obs_file:
shld_be = 1 + np.arange(len(obs_file['obsHistID'].value), dtype=int)
np.testing.assert_array_equal(shld_be, obs_file['obsHistID'].value)
np.testing.assert_array_equal(obs_file['obsHistID'].value[obs_dex_list],
obs_list)
obs_subset = {}
for field_name in obs_file.keys():
obs_subset[field_name] = obs_file[field_name].value[obs_dex_list]
trixel_of_interest = htm.trixelFromHtmid(htmid_of_interest)
trixel_ra, trixel_dec = trixel_of_interest.get_center()
trixel_radius = 1.05*trixel_of_interest.get_radius()
trixel_obs = sims_utils.ObservationMetaData(pointingRA=trixel_ra,
pointingDec=trixel_dec,
boundType='circle',
boundLength=trixel_radius)
star_iter = star_db.query_columns(col_names,
obs_metadata=trixel_obs,
chunk_size=100000)
ct_tot = 0
ct_kplr = 0
ct_mlt = 0
ct_rrly = 0
t_start = time.time()
for chunk in star_iter:
chunk_htmid = chunk['htmID']>>(2*(21-htmid_level_of_interest))
valid = np.where(chunk_htmid==htmid_of_interest)
if len(valid[0]) == 0:
def test_raDecFromAltAz(self):
"""
Test conversion of Alt, Az to Ra, Dec using data on the Sun
This site gives the altitude and azimuth of the Sun as a function
of time and position on the earth
http://aa.usno.navy.mil/data/docs/AltAz.php
This site gives the apparent geocentric RA, Dec of major celestial objects
as a function of time
http://aa.usno.navy.mil/data/docs/geocentric.php
This site converts calendar dates into Julian Dates
http://aa.usno.navy.mil/data/docs/JulianDate.php
"""
hours = np.radians(360.0 / 24.0)
minutes = hours / 60.0
seconds = minutes / 60.0
longitude_list = []
latitude_list = []
mjd_list = []
alt_list = []
az_list = []
ra_app_list = []
dec_app_list = []
longitude_list.append(np.radians(-22.0 - 33.0 / 60.0))
latitude_list.append(np.radians(11.0 + 45.0 / 60.0))
mjd_list.append(2457364.958333 - 2400000.5) # 8 December 2015 11:00 UTC
alt_list.append(np.radians(41.1))
az_list.append(np.radians(134.7))
ra_app_list.append(16.0 * hours + 59.0 * minutes + 16.665 * seconds)
dec_app_list.append(np.radians(-22.0 - 42.0 / 60.0 - 2.94 / 3600.0))
longitude_list.append(np.radians(-22.0 - 33.0 / 60.0))
latitude_list.append(np.radians(11.0 + 45.0 / 60.0))
mjd_list.append(2457368.958333 - 2400000.5) # 12 December 2015 11:00 UTC
alt_list.append(np.radians(40.5))
az_list.append(np.radians(134.7))
ra_app_list.append(17.0 * hours + 16.0 * minutes + 51.649 * seconds)
dec_app_list.append(np.radians(-23.0 - 3 / 60.0 - 50.35 / 3600.0))
longitude_list.append(np.radians(145.0 + 23.0 / 60.0))
latitude_list.append(np.radians(-64.0 - 5.0 / 60.0))
mjd_list.append(2456727.583333 - 2400000.5) # 11 March 2014, 02:00 UTC
alt_list.append(np.radians(29.5))
az_list.append(np.radians(8.2))
ra_app_list.append(23.0 * hours + 24.0 * minutes + 46.634 * seconds)
dec_app_list.append(np.radians(-3.0 - 47.0 / 60.0 - 47.81 / 3600.0))
longitude_list.append(np.radians(145.0 + 23.0 / 60.0))
latitude_list.append(np.radians(-64.0 - 5.0 / 60.0))
mjd_list.append(2456731.583333 - 2400000.5) # 15 March 2014, 02:00 UTC
alt_list.append(np.radians(28.0))
az_list.append(np.radians(7.8))
ra_app_list.append(23.0 * hours + 39.0 * minutes + 27.695 * seconds)
dec_app_list.append(np.radians(-2.0 - 13.0 / 60.0 - 18.32 / 3600.0))
for longitude, latitude, mjd, alt, az, ra_app, dec_app in \
zip(longitude_list, latitude_list, mjd_list, alt_list, az_list,
ra_app_list, dec_app_list):
obs = utils.ObservationMetaData(site=utils.Site(longitude=np.degrees(longitude),
latitude=np.degrees(latitude), name='LSST'),
mjd=utils.ModifiedJulianDate(UTC=mjd))
ra_icrs, dec_icrs = utils._raDecFromAltAz(alt, az, obs)
ra_test, dec_test = utils._appGeoFromICRS(ra_icrs, dec_icrs, mjd=obs.mjd)
distance = np.degrees(utils.haversine(ra_app, dec_app, ra_test, dec_test))
# this is all the precision we have in the alt,az data taken from the USNO
self.assertLess(distance, 0.1)
correction = np.degrees(utils.haversine(ra_test, dec_test, ra_icrs, dec_icrs))
self.assertLess(distance, correction)
cadence_file_name = args.out_file
if os.path.exists(cadence_file_name):
os.unlink(cadence_file_name)
dtype = np.dtype([('id', int), ('ra', float), ('dec', float),
('mjd', float), ('rawSeeing', float), ('filter', str, 1),
('rotSkyPos', float)])
data_file = args.in_file
data = np.genfromtxt(data_file, dtype=dtype, delimiter=',', skip_header=1)
rotTelPos = []
for ii in range(len(data)):
obs = sims_utils.ObservationMetaData(
pointingRA=np.degrees(data['ra'][ii]),
pointingDec=np.degrees(data['dec'][ii]),
mjd=data['mjd'][ii])
rottel = sims_utils._getRotTelPos(data['ra'][ii], data['dec'][ii], obs,
data['rotSkyPos'][ii])
rotTelPos.append(rottel)
with sqlite3.connect(cadence_file_name) as conn:
cur = conn.cursor()
cur.execute('''CREATE TABLE Summary(obsHistID int,
descDitheredRA real, descDitheredDec real,
expMJD real, rawSeeing real, filter text,
rotSkyPos real, descDitheredRotTelPos real,
fieldRA real, fieldDec real)''')
conn.commit()
values = ((int(data['id'][ii]), data['ra'][ii], data['dec'][ii],
