def testRaDecFromAltAz(self):
azList = self.raList
altList = self.decList
mjd = 47895.6
obs = ObservationMetaData(mjd=mjd, site=Site(longitude=self.lon, latitude=self.lat, name='LSST'))
raRad, decRad = utils._raDecFromAltAz(altList, azList, obs)
raDeg, decDeg = utils.raDecFromAltAz(np.degrees(altList),
np.degrees(azList), obs)
np.testing.assert_array_almost_equal(raRad, np.radians(raDeg), 10)
np.testing.assert_array_almost_equal(decRad, np.radians(decDeg), 10)
raRad, decRad = utils._raDecFromAltAz(altList, azList, obs)
raDeg, decDeg = utils.raDecFromAltAz(np.degrees(altList),
np.degrees(azList), obs)
np.testing.assert_array_almost_equal(raRad, np.radians(raDeg), 10)
np.testing.assert_array_almost_equal(decRad, np.radians(decDeg), 10)
for alt, az in zip(altList, azList):
raRad, decRad = utils._raDecFromAltAz(alt, az, obs)
raDeg, decDeg = utils.raDecFromAltAz(np.degrees(alt),
np.degrees(az), obs)
self.assertAlmostEqual(raRad, np.radians(raDeg), 10)
self.assertAlmostEqual(decRad, np.radians(decDeg), 10)
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 testRaDecFromAltAz(self):
azList = self.raList
altList = self.decList
mjd = 47895.6
obs = ObservationMetaData(mjd=mjd,
site=Site(longitude=self.lon,
latitude=self.lat,
name='LSST'))
raRad, decRad = utils._raDecFromAltAz(altList, azList, obs)
raDeg, decDeg = utils.raDecFromAltAz(np.degrees(altList),
np.degrees(azList), obs)
np.testing.assert_array_almost_equal(raRad, np.radians(raDeg), 10)
np.testing.assert_array_almost_equal(decRad, np.radians(decDeg), 10)
raRad, decRad = utils._raDecFromAltAz(altList, azList, obs)
raDeg, decDeg = utils.raDecFromAltAz(np.degrees(altList),
np.degrees(azList), obs)
np.testing.assert_array_almost_equal(raRad, np.radians(raDeg), 10)
np.testing.assert_array_almost_equal(decRad, np.radians(decDeg), 10)
for alt, az in zip(altList, azList):
raRad, decRad = utils._raDecFromAltAz(alt, az, obs)
raDeg, decDeg = utils.raDecFromAltAz(np.degrees(alt),
np.degrees(az), obs)
self.assertAlmostEqual(raRad, np.radians(raDeg), 10)
self.assertAlmostEqual(decRad, np.radians(decDeg), 10)
def makeObservationMetaData():
#create a cartoon ObservationMetaData object
mjd = 52000.0
alt = numpy.pi/2.0
az = 0.0
band = 'r'
testSite = Site(latitude=numpy.degrees(0.5), longitude=numpy.degrees(1.1), height=3000,
temperature=260.0, pressure=725.0, lapseRate=0.005, humidity=0.4)
obsTemp = ObservationMetaData(site=testSite, mjd=mjd)
centerRA, centerDec = _raDecFromAltAz(alt, az, obsTemp)
rotTel = _getRotTelPos(centerRA, centerDec, obsTemp, 0.0)
obsDict = calcObsDefaults(centerRA, centerDec, alt, az, rotTel, mjd, band,
testSite.longitude_rad, testSite.latitude_rad)
obsDict['Opsim_expmjd'] = mjd
radius = 0.1
phoSimMetaData = OrderedDict([
(k, (obsDict[k],numpy.dtype(type(obsDict[k])))) for k in obsDict])
obs_metadata = ObservationMetaData(boundType='circle', boundLength=2.0*radius,
phoSimMetaData=phoSimMetaData, site=testSite)
return obs_metadata
def setRaDecMjd(self, lon, lat, mjd, degrees=False, azAlt=False, solarFlux=130.):
"""
Set the sky parameters by computing the sky conditions on a given MJD and sky location.
lon: Longitude-like (RA or Azimuth). Can be single number, list, or numpy array
lat: Latitude-like (Dec or Altitude)
mjd: Modified Julian Date for the calculation. Must be single number.
degrees: (False) Assumes lon and lat are radians unless degrees=True
azAlt: (False) Assume lon, lat are RA, Dec unless azAlt=True
solarFlux: solar flux in SFU Between 50 and 310. Default=130. 1 SFU=10^4 Jy.
"""
# Wrap in array just in case single points were passed
if not type(lon).__module__ == np.__name__:
if np.size(lon) == 1:
lon = np.array([lon]).ravel()
lat = np.array([lat]).ravel()
else:
lon = np.array(lon)
lat = np.array(lat)
if degrees:
self.ra = np.radians(lon)
self.dec = np.radians(lat)
else:
self.ra = lon
self.dec = lat
if np.size(mjd) > 1:
raise ValueError('mjd must be single value.')
self.mjd = mjd
if azAlt:
self.azs = self.ra.copy()
self.alts = self.dec.copy()
if self.preciseAltAz:
self.ra, self.dec = _raDecFromAltAz(self.alts, self.azs,
ObservationMetaData(mjd=self.mjd, site=self.telescope))
else:
self.ra, self.dec = stupidFast_altAz2RaDec(self.alts, self.azs,
self.telescope.latitude_rad,
self.telescope.longitude_rad, mjd)
else:
if self.preciseAltAz:
self.alts, self.azs, pa = _altAzPaFromRaDec(self.ra, self.dec,
ObservationMetaData(mjd=self.mjd,
site=self.telescope))
else:
self.alts, self.azs = stupidFast_RaDec2AltAz(self.ra, self.dec,
self.telescope.latitude_rad,
self.telescope.longitude_rad, mjd)
self.npts = self.ra.size
self._initPoints()
self.solarFlux = solarFlux
self.points['solarFlux'] = self.solarFlux
self._setupPointGrid()
self.paramsSet = True
# Interpolate the templates to the set paramters
self.interpSky()
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 testaltaz2radec(self):
np.random.seed(42)
az = np.random.rand(100)*np.pi*2
alt = np.random.rand(100)*np.pi-np.pi/2
site = Site('LSST')
mjd = 55000
omd = ObservationMetaData(mjd=mjd,site=site)
trueRA,trueDec = _raDecFromAltAz(alt,az, omd)
fastRA,fastDec = sb.stupidFast_altAz2RaDec(alt,az,site.latitude_rad,
site.longitude_rad,mjd)
distanceDiff = haversine(trueRA,trueDec, fastRA,fastDec)
degreeTol =2. # 2-degree tolerance on the fast transform
assert(np.degrees(distanceDiff.max()) < degreeTol)
def testaltaz2radec(self):
np.random.seed(42)
az = np.random.rand(100) * np.pi * 2
alt = np.random.rand(100) * np.pi - np.pi / 2
site = Site('LSST')
mjd = 55000
omd = ObservationMetaData(mjd=mjd, site=site)
trueRA, trueDec = _raDecFromAltAz(alt, az, omd)
fastRA, fastDec = sb.stupidFast_altAz2RaDec(alt, az, site.latitude_rad,
site.longitude_rad, mjd)
distanceDiff = haversine(trueRA, trueDec, fastRA, fastDec)
degreeTol = 2. # 2-degree tolerance on the fast transform
assert (np.degrees(distanceDiff.max()) < degreeTol)
def test_icrsFromObserved(self):
"""
Test that _icrsFromObserved really inverts _observedFromAppGeo.
In this case, the method is only reliable at distances of more than
45 degrees from the sun and at zenith distances less than 70 degrees.
"""
numpy.random.seed(412)
nSamples = 100
mjd2000 = pal.epb(2000.0) # convert epoch to mjd
site = Site(name='LSST')
for mjd in (53000.0, 53241.6, 58504.6):
for includeRefraction in (True, False):
for raPointing in (23.5, 256.9, 100.0):
for decPointing in (-12.0, 45.0, 66.8):
obs = ObservationMetaData(mjd=mjd, site=site)
raZenith, decZenith = _raDecFromAltAz(0.5*numpy.pi, 0.0, obs)
obs = ObservationMetaData(pointingRA=raPointing, pointingDec=decPointing,
mjd=mjd, site=site)
rr = numpy.random.random_sample(nSamples)*numpy.radians(50.0)
theta = numpy.random.random_sample(nSamples)*2.0*numpy.pi
ra_in = raZenith + rr*numpy.cos(theta)
dec_in = decZenith + rr*numpy.sin(theta)
# test a round-trip between observedFromICRS and icrsFromObserved
ra_obs, dec_obs = _observedFromICRS(ra_in, dec_in, obs_metadata=obs,
includeRefraction=includeRefraction,
epoch=2000.0)
ra_icrs, dec_icrs = _icrsFromObserved(ra_obs, dec_obs, obs_metadata=obs,
includeRefraction=includeRefraction,
epoch=2000.0)
valid_pts = numpy.where(_distanceToSun(ra_in, dec_in, mjd)>0.25*numpy.pi)[0]
self.assertGreater(len(valid_pts), 0)
distance = arcsecFromRadians(pal.dsepVector(ra_in[valid_pts], dec_in[valid_pts],
ra_icrs[valid_pts], dec_icrs[valid_pts]))
self.assertLess(distance.max(), 0.01)
# test a round-trip between observedFromAppGeo and appGeoFromObserved
ra_obs, dec_obs = _observedFromAppGeo(ra_in, dec_in, obs_metadata=obs,
includeRefraction=includeRefraction)
ra_app, dec_app = _appGeoFromObserved(ra_obs, dec_obs, obs_metadata=obs,
includeRefraction=includeRefraction)
distance = arcsecFromRadians(pal.dsepVector(ra_in[valid_pts], dec_in[valid_pts],
ra_app[valid_pts], dec_app[valid_pts]))
self.assertLess(distance.max(), 0.01)
def makePhoSimTestDB(filename='PhoSimTestDatabase.db',
size=1000,
seedVal=32,
radius=0.1,
deltaRA=None,
deltaDec=None,
bandpass='******',
m5=None,
seeing=None,
magnorm_min=17.0,
delta_magnorm=4.0,
**kwargs):
"""
Make a test database to storing cartoon information for the test phoSim input
catalog to use.
The method will return an ObservationMetaData object guaranteed to encompass the
objects in this database.
@param [in] filename is a string indicating the name of the DB file to be created
@param [in] size is the number of objects int he database
@param [in] seedVal is the seed passed to the random number generator
@param [in] radius is the radius (in degrees) of the field of view to be returned
@param [in] bandpass is the bandpas(es) of the observation to be passed to
ObservationMetaData (optional)
@param [in] m5 is the m5 value(s) to be passed to ObservationMetaData
(optional)
@param [in] seeing is the seeing value(s) in arcseconds to be passed to
ObservationMetaData (optional)
@param [in] deltaRA/Dec are numpy arrays that indicate where (in relation to the center
of the field of view) objects should be placed. These coordinates are in degrees. Specifying
either of these paramters will overwrite size. If you only specify one of these parameters, the other
will be set randomly. These parameters are optional.
@param [in] magnorm_min is the min magnorm (magNorms for sources in the database will be
distributed according to a random deviate drawn from magnorm_min + random*delta_magnorm)
@param [in] delta_magnorm (see documentation for magnorm_min)
"""
if os.path.exists(filename):
os.unlink(filename)
# just an example of some valid SED file names
galaxy_seds = [
'Const.80E07.02Z.spec', 'Inst.80E07.002Z.spec',
'Burst.19E07.0005Z.spec'
]
agn_sed = 'agn.spec'
star_seds = [
'km20_5750.fits_g40_5790', 'm2.0Full.dat', 'bergeron_6500_85.dat_6700'
]
rng = np.random.RandomState(seedVal)
if deltaRA is not None and deltaDec is not None:
if len(deltaRA) != len(deltaDec):
raise RuntimeError("WARNING in makePhoSimTestDB deltaRA and "
"deltaDec have different lengths")
if deltaRA is not None:
size = len(deltaRA)
elif deltaDec is not None:
size = len(deltaDec)
# create the ObservationMetaData object
mjd = 52000.0
alt = np.pi / 2.0
az = 0.0
testSite = Site(name='LSST')
obsTemp = ObservationMetaData(mjd=mjd, site=testSite)
centerRA, centerDec = _raDecFromAltAz(alt, az, obsTemp)
rotTel = _getRotTelPos(centerRA, centerDec, obsTemp, 0.0)
rotSkyPos = _getRotSkyPos(centerRA, centerDec, obsTemp, rotTel)
obs_metadata = ObservationMetaData(pointingRA=np.degrees(centerRA),
pointingDec=np.degrees(centerDec),
rotSkyPos=np.degrees(rotSkyPos),
bandpassName=bandpass,
mjd=mjd,
boundType='circle',
boundLength=2.0 * radius,
site=testSite,
m5=m5,
seeing=seeing)
moon_alt = -90.0
sun_alt = -90.0
moon_ra, moon_dec = raDecFromAltAz(moon_alt, 0.0, obs_metadata)
dist2moon = haversine(np.radians(moon_ra), np.radians(moon_dec),
obs_metadata._pointingRA, obs_metadata._pointingDec)
obs_metadata.OpsimMetaData = {
'moonra': moon_ra,
'moondec': moon_dec,
'moonalt': moon_alt,
'sunalt': sun_alt,
'dist2moon': dist2moon,
'rottelpos': np.degrees(rotTel)
}
# Now begin building the database.
# First create the tables.
conn = sqlite3.connect(filename)
c = conn.cursor()
try:
c.execute('''CREATE TABLE galaxy_bulge
(galtileid int, galid int, bra real, bdec real, ra real, dec real, magnorm_bulge real,
sedname_bulge text, a_b real, b_b real, pa_bulge real, bulge_n int,
ext_model_b text, av_b real, rv_b real, u_ab real, g_ab real, r_ab real, i_ab real,
z_ab real, y_ab real, redshift real, BulgeHalfLightRadius real)'''
)
conn.commit()
except:
raise RuntimeError("Error creating galaxy_bulge table.")
try:
c.execute('''CREATE TABLE galaxy
(galtileid int, galid int, ra real, dec real,
bra real, bdec real, dra real, ddec real,
agnra real, agndec real,
magnorm_bulge, magnorm_disk, magnorm_agn,
sedname_bulge text, sedname_disk text, sedname_agn text,
varParamStr text,
a_b real, b_b real, pa_bulge real, bulge_n int,
a_d real, b_d real, pa_disk real, disk_n int,
ext_model_b text, av_b real, rv_b real,
ext_model_d text, av_d real, rv_d real,
u_ab real, g_ab real, r_ab real, i_ab real,
z_ab real, y_ab real,
redshift real, BulgeHalfLightRadius real, DiskHalfLightRadius real)'''
)
conn.commit()
except:
raise RuntimeError("Error creating galaxy table.")
try:
c.execute('''CREATE TABLE galaxy_agn
(galtileid int, galid int, agnra real, agndec real, ra real, dec real,
magnorm_agn real, sedname_agn text, varParamStr text, u_ab real,
g_ab real, r_ab real, i_ab real, z_ab real, y_ab real, redshift real)'''
)
except:
raise RuntimeError("Error creating galaxy_agn table.")
try:
c.execute('''CREATE TABLE StarAllForceseek
(simobjid int, ra real, decl real, magNorm real,
mudecl real, mura real, galacticAv real, vrad real, varParamStr text,
sedFilename text, parallax real, ebv real)''')
except:
raise RuntimeError("Error creating StarAllForceseek table.")
# Now generate the data to be stored in the tables.
rr = rng.random_sample(size) * np.radians(radius)
theta = rng.random_sample(size) * 2.0 * np.pi
if deltaRA is None:
ra = np.degrees(centerRA + rr * np.cos(theta))
else:
ra = np.degrees(centerRA) + deltaRA
if deltaDec is None:
dec = np.degrees(centerDec + rr * np.sin(theta))
else:
dec = np.degrees(centerDec) + deltaDec
bra = np.radians(ra + rng.random_sample(size) * 0.01 * radius)
bdec = np.radians(dec + rng.random_sample(size) * 0.01 * radius)
dra = np.radians(ra + rng.random_sample(size) * 0.01 * radius)
ddec = np.radians(dec + rng.random_sample(size) * 0.01 * radius)
agnra = np.radians(ra + rng.random_sample(size) * 0.01 * radius)
agndec = np.radians(dec + rng.random_sample(size) * 0.01 * radius)
magnorm_bulge = rng.random_sample(size) * delta_magnorm + magnorm_min
magnorm_disk = rng.random_sample(size) * delta_magnorm + magnorm_min
magnorm_agn = rng.random_sample(size) * delta_magnorm + magnorm_min
b_b = rng.random_sample(size) * 0.2
a_b = b_b + rng.random_sample(size) * 0.05
b_d = rng.random_sample(size) * 0.5
a_d = b_d + rng.random_sample(size) * 0.1
BulgeHalfLightRadius = rng.random_sample(size) * 0.2
DiskHalfLightRadius = rng.random_sample(size) * 0.5
pa_bulge = rng.random_sample(size) * 360.0
pa_disk = rng.random_sample(size) * 360.0
av_b = rng.random_sample(size) * 0.3
av_d = rng.random_sample(size) * 0.3
rv_b = rng.random_sample(size) * 0.1 + 2.0
rv_d = rng.random_sample(size) * 0.1 + 2.0
u_ab = rng.random_sample(size) * 4.0 + 17.0
g_ab = rng.random_sample(size) * 4.0 + 17.0
r_ab = rng.random_sample(size) * 4.0 + 17.0
i_ab = rng.random_sample(size) * 4.0 + 17.0
z_ab = rng.random_sample(size) * 4.0 + 17.0
y_ab = rng.random_sample(size) * 4.0 + 17.0
redshift = rng.random_sample(size) * 2.0
t0_mjd = mjd - rng.random_sample(size) * 1000.0
agn_tau = rng.random_sample(size) * 1000.0 + 1000.0
agnSeed = rng.randint(2, 4001, size=size)
agn_sfu = rng.random_sample(size)
agn_sfg = rng.random_sample(size)
agn_sfr = rng.random_sample(size)
agn_sfi = rng.random_sample(size)
agn_sfz = rng.random_sample(size)
agn_sfy = rng.random_sample(size)
rrStar = rng.random_sample(size) * np.radians(radius)
thetaStar = rng.random_sample(size) * 2.0 * np.pi
if deltaRA is None:
raStar = centerRA + rrStar * np.cos(thetaStar)
else:
raStar = centerRA + np.radians(deltaRA)
if deltaDec is None:
decStar = centerDec + rrStar * np.sin(thetaStar)
else:
decStar = centerDec + np.radians(deltaDec)
raStar = np.degrees(raStar)
decStar = np.degrees(decStar)
magnormStar = rng.random_sample(size) * delta_magnorm + magnorm_min
mudecl = rng.random_sample(size) * 0.0001
mura = rng.random_sample(size) * 0.0001
galacticAv = rng.random_sample(size) * 0.05 * 3.1
vrad = rng.random_sample(size) * 1.0
parallax = 0.00045 + rng.random_sample(size) * 0.00001
period = rng.random_sample(size) * 20.0
amp = rng.random_sample(size) * 5.0
# write the data to the tables.
for i in range(size):
cmd = '''INSERT INTO galaxy_bulge VALUES (%i, %i, %f, %f, %f, %f, %f,
'%s', %f, %f, %f, %i, '%s', %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)''' % \
(i, i, bra[i], bdec[i], ra[i], dec[i], magnorm_bulge[i], galaxy_seds[i%len(galaxy_seds)],
a_b[i], b_b[i], pa_bulge[i], 4, 'CCM', av_b[i], rv_b[i], u_ab[i], g_ab[i],
r_ab[i], i_ab[i], z_ab[i], y_ab[i], redshift[i], BulgeHalfLightRadius[i])
c.execute(cmd)
varParam = {
'varMethodName': 'applyAgn',
'pars': {
'agn_tau': round(agn_tau[i], 4),
't0_mjd': round(t0_mjd[i], 4),
'agn_sfu': round(agn_sfu[i], 4),
'agn_sfg': round(agn_sfg[i], 4),
'agn_sfr': round(agn_sfr[i], 4),
'agn_sfi': round(agn_sfi[i], 4),
'agn_sfz': round(agn_sfz[i], 4),
'agn_sfy': round(agn_sfy[i], 4),
'seed': int(agnSeed[i])
}
}
paramStr = json.dumps(varParam)
cmd = '''INSERT INTO galaxy VALUES (%i, %i, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f,
'%s', '%s', '%s', '%s',
%f, %f, %f, %i,
%f, %f, %f, %i,
'%s', %f, %f,
'%s', %f, %f,
%f, %f, %f, %f, %f, %f,
%f, %f, %f)''' % \
(i, i, ra[i], dec[i], bra[i], bdec[i], dra[i], ddec[i], agnra[i], agndec[i],
magnorm_bulge[i], magnorm_disk[i], magnorm_agn[i],
galaxy_seds[i%len(galaxy_seds)], galaxy_seds[i%len(galaxy_seds)], agn_sed,
paramStr,
a_b[i], b_b[i], pa_bulge[i], 4,
a_d[i], b_d[i], pa_disk[i], 1,
'CCM', av_b[i], rv_b[i],
'CCM', av_d[i], rv_d[i],
u_ab[i], g_ab[i], r_ab[i], i_ab[i], z_ab[i], y_ab[i], redshift[i],
BulgeHalfLightRadius[i], DiskHalfLightRadius[i])
c.execute(cmd)
cmd = '''INSERT INTO galaxy_agn VALUES (%i, %i, %f, %f, %f, %f, %f, '%s', '%s',
%f, %f, %f, %f, %f, %f, %f)''' % \
(i, i, agnra[i], agndec[i], ra[i], dec[i],
magnorm_agn[i], agn_sed, paramStr,
u_ab[i], g_ab[i], r_ab[i], i_ab[i],
z_ab[i], y_ab[i], redshift[i])
c.execute(cmd)
varParam = {
'varMethodName': 'testVar',
'pars': {
'period': period[i],
'amplitude': amp[i]
}
}
paramStr = json.dumps(varParam)
cmd = '''INSERT INTO StarAllForceseek VALUES (%i, %f, %f, %f, %f, %f, %f, %f, '%s', '%s', %f, %f)''' %\
(i, raStar[i], decStar[i], magnormStar[i], mudecl[i], mura[i],
galacticAv[i], vrad[i], paramStr, star_seds[i%len(star_seds)], parallax[i],
galacticAv[i]/3.1)
c.execute(cmd)
conn.commit()
conn.close()
return obs_metadata
# Let's recreate the delta m_5 plot from figure 3 in:
# http://xxx.lanl.gov/pdf/1510.07574.pdf
telescope = Site('LSST')
nside = 32
lat, ra = hp.pix2ang(nside, np.arange(hp.nside2npix(nside)))
dec = np.pi/2-lat
kwargs = dict(twilight=False, zodiacal=False, moon=True, scatteredStar=False, mergedSpec=False)
sm = sb.SkyModel(observatory='LSST', mags=True) # , **kwargs)
mjd = 49353.177645
sm.setRaDecMjd(ra, dec, mjd)
mag = sm.returnMags()
lmst, last = calcLmstLast(mjd, telescope.longitude_rad)
moonRA, moonDec = _raDecFromAltAz(sm.moonAlt, sm.moonAz, ObservationMetaData(mjd=mjd, site=telescope))
alt, az, pa = _altAzPaFromRaDec(ra, dec, ObservationMetaData(mjd=mjd, site=telescope))
angDist2Moon = np.degrees(haversine(az, alt, sm.moonAz, sm.moonAlt))
ang2 = np.degrees(haversine(ra, dec, moonRA, moonDec))
alt = np.degrees(alt)
mags = -0.5*(np.nanmin(mag['u'])-mag['u'])
#extent = (0,130, 0,90)
extent = (20, 120, 20, 90)
xs, ys = np.mgrid[extent[0]:extent[1], extent[2]:extent[3]]
resampled = griddata((angDist2Moon, alt), mags, (xs, ys))
notInf = np.where((resampled != np.inf) & (~np.isnan(resampled)))
np.radians(skydata['dec']),
telescope.lon, telescope.lat,
mjd)
skyhp = healbin(az, alt, skydata['sky'], nside=nside)
skyhp[np.isnan(skyhp)] = hp.UNSEEN
good = np.where(skyhp != hp.UNSEEN)
sm.setRaDecMjd(hpra[good],
hpdec[good],
mjd,
degrees=False,
azAlt=True)
# switch moon to ra dec
moonRA, moonDec = _raDecFromAltAz(sm.moonAlt, sm.moonAz,
telescope.lon, telescope.lat,
mjd)
# compute distances
moonDistances = haversine(hpra[good], hpdec[good], moonRA,
moonDec)
closeToMoon = np.where(moonDistances < np.radians(moonLimit))
modelhp = np.zeros(npix, dtype=float) + hp.UNSEEN
modelhp[good] = sm.returnMags(canonDict[filterName])
modelhp[good][closeToMoon] = hp.UNSEEN
good = np.where(modelhp != hp.UNSEEN)
validationArr['frameZP'][i] = np.median(modelhp[good] -
skyhp[good])
notnan = np.where(skyhp != hp.UNSEEN)
validationArr['obsDarkestHP'][i] = np.where(
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)
def setRaDecMjd(self, lon, lat, mjd, degrees=False, azAlt=False, solarFlux=130.,
filterNames=['u', 'g', 'r', 'i', 'z', 'y']):
"""
Set the sky parameters by computing the sky conditions on a given MJD and sky location.
lon: Longitude-like (RA or Azimuth). Can be single number, list, or numpy array
lat: Latitude-like (Dec or Altitude)
mjd: Modified Julian Date for the calculation. Must be single number.
degrees: (False) Assumes lon and lat are radians unless degrees=True
azAlt: (False) Assume lon, lat are RA, Dec unless azAlt=True
solarFlux: solar flux in SFU Between 50 and 310. Default=130. 1 SFU=10^4 Jy.
filterNames: list of fitlers to return magnitudes for (if initialized with mags=True).
"""
self.filterNames = filterNames
if self.mags:
self.npix = len(self.filterNames)
# Wrap in array just in case single points were passed
if np.size(lon) == 1:
lon = np.array([lon]).ravel()
lat = np.array([lat]).ravel()
else:
lon = np.array(lon)
lat = np.array(lat)
if degrees:
self.ra = np.radians(lon)
self.dec = np.radians(lat)
else:
self.ra = lon
self.dec = lat
if np.size(mjd) > 1:
raise ValueError('mjd must be single value.')
self.mjd = mjd
if azAlt:
self.azs = self.ra.copy()
self.alts = self.dec.copy()
if self.preciseAltAz:
self.ra, self.dec = _raDecFromAltAz(self.alts, self.azs,
ObservationMetaData(mjd=self.mjd, site=self.telescope))
else:
self.ra, self.dec = _approx_altAz2RaDec(self.alts, self.azs,
self.telescope.latitude_rad,
self.telescope.longitude_rad, mjd)
else:
if self.preciseAltAz:
self.alts, self.azs, pa = _altAzPaFromRaDec(self.ra, self.dec,
ObservationMetaData(mjd=self.mjd,
site=self.telescope))
else:
self.alts, self.azs = _approx_RaDec2AltAz(self.ra, self.dec,
self.telescope.latitude_rad,
self.telescope.longitude_rad, mjd)
self.npts = self.ra.size
self._initPoints()
self.solarFlux = solarFlux
self.points['solarFlux'] = self.solarFlux
self._setupPointGrid()
self.paramsSet = True
# Assume large airmasses are the same as airmass=2.5
to_fudge = np.where((self.points['airmass'] > 2.5) & (self.points['airmass'] < self.airmassLimit))
self.points['airmass'][to_fudge] = 2.499
self.points['alt'][to_fudge] = np.pi/2-np.arccos(1./self.airmassLimit)
# Interpolate the templates to the set paramters
self.goodPix = np.where((self.airmass <= self.airmassLimit) & (self.airmass >= 1.))[0]
if self.goodPix.size > 0:
self._interpSky()
else:
warnings.warn('No valid points to interpolate')
def setRaDecMjd(self,lon,lat,mjd,degrees=False,azAlt=False,solarFlux=130.):
"""
Set the sky parameters by computing the sky conditions on a given MJD and sky location.
Ra and Dec in raidans or degrees.
input ra, dec or az,alt w/ altAz=True
solarFlux: solar flux in s.f.u. Between 50 and 310.
"""
# Wrap in array just in case single points were passed
if not type(lon).__module__ == np.__name__ :
if np.size(lon) == 1:
lon = np.array([lon])
lat = np.array([lat])
else:
lon = np.array(lon)
lat = np.array(lat)
if degrees:
self.ra = np.radians(lon)
self.dec = np.radians(lat)
else:
self.ra = lon
self.dec = lat
self.mjd = mjd
if azAlt:
self.azs = self.ra.copy()
self.alts = self.dec.copy()
self.ra,self.dec = _raDecFromAltAz(self.alts,self.azs, self.Observatory.lon,
self.Observatory.lat, self.mjd)
else:
self.alts,self.azs,pa = _altAzPaFromRaDec(self.ra, self.dec, self.Observatory.lon,
self.Observatory.lat, self.mjd)
self.npts = self.ra.size
self._initPoints()
self.solarFlux = solarFlux
self.points['solarFlux'] = self.solarFlux
# Switch to Dublin Julian Date for pyephem
self.Observatory.date = mjd2djd(self.mjd)
sun = ephem.Sun()
sun.compute(self.Observatory)
self.sunAlt = sun.alt
self.sunAz = sun.az
# Compute airmass the same way as ESO model
self.airmass = 1./np.cos(np.pi/2.-self.alts)
self.points['airmass'] = self.airmass
self.points['nightTimes'] = 2
self.points['alt'] = self.alts
self.points['az'] = self.azs
if self.twilight:
self.points['sunAlt'] = self.sunAlt
self.points['azRelSun'] = wrapRA(self.azs - self.sunAz)
if self.moon:
moon = ephem.Moon()
moon.compute(self.Observatory)
self.moonPhase = moon.phase
self.moonAlt = moon.alt
self.moonAz = moon.az
# Calc azimuth relative to moon
self.azRelMoon = wrapRA(self.azs - self.moonAz)
over = np.where(self.azRelMoon > np.pi)
self.azRelMoon[over] = 2.*np.pi - self.azRelMoon[over]
self.points['moonAltitude'] += np.degrees(self.moonAlt)
self.points['azRelMoon'] += self.azRelMoon
self.points['moonSunSep'] += self.moonPhase/100.*180.
if self.zodiacal:
self.eclipLon = np.zeros(self.npts)
self.eclipLat = np.zeros(self.npts)
for i,temp in enumerate(self.ra):
eclip = ephem.Ecliptic(ephem.Equatorial(self.ra[i],self.dec[i], epoch='2000'))
self.eclipLon[i] += eclip.lon
self.eclipLat[i] += eclip.lat
# Subtract off the sun ecliptic longitude
sunEclip = ephem.Ecliptic(sun)
self.sunEclipLon = sunEclip.lon
self.points['altEclip'] += self.eclipLat
self.points['azEclipRelSun'] += wrapRA(self.eclipLon - self.sunEclipLon)
def makePhoSimTestDB(filename='PhoSimTestDatabase.db', size=1000, seedVal=32, radius=0.1,
deltaRA=None, deltaDec=None,
bandpass='******', m5=None, seeing=None,
magnorm_min=17.0, delta_magnorm=4.0, **kwargs):
"""
Make a test database to storing cartoon information for the test phoSim input
catalog to use.
The method will return an ObservationMetaData object guaranteed to encompass the
objects in this database.
@param [in] filename is a string indicating the name of the DB file to be created
@param [in] size is the number of objects int he database
@param [in] seedVal is the seed passed to the random number generator
@param [in] radius is the radius (in degrees) of the field of view to be returned
@param [in] bandpass is the bandpas(es) of the observation to be passed to
ObservationMetaData (optional)
@param [in] m5 is the m5 value(s) to be passed to ObservationMetaData
(optional)
@param [in] seeing is the seeing value(s) in arcseconds to be passed to
ObservationMetaData (optional)
@param [in] deltaRA/Dec are numpy arrays that indicate where (in relation to the center
of the field of view) objects should be placed. These coordinates are in degrees. Specifying
either of these paramters will overwrite size. If you only specify one of these parameters, the other
will be set randomly. These parameters are optional.
@param [in] magnorm_min is the min magnorm (magNorms for sources in the database will be
distributed according to a random deviate drawn from magnorm_min + random*delta_magnorm)
@param [in] delta_magnorm (see documentation for magnorm_min)
"""
if os.path.exists(filename):
os.unlink(filename)
# just an example of some valid SED file names
galaxy_seds = ['Const.80E07.02Z.spec', 'Inst.80E07.002Z.spec', 'Burst.19E07.0005Z.spec']
agn_sed = 'agn.spec'
star_seds = ['km20_5750.fits_g40_5790', 'm2.0Full.dat', 'bergeron_6500_85.dat_6700']
rng = np.random.RandomState(seedVal)
if deltaRA is not None and deltaDec is not None:
if len(deltaRA) != len(deltaDec):
raise RuntimeError("WARNING in makePhoSimTestDB deltaRA and "
"deltaDec have different lengths")
if deltaRA is not None:
size = len(deltaRA)
elif deltaDec is not None:
size = len(deltaDec)
# create the ObservationMetaData object
mjd = 52000.0
alt = np.pi/2.0
az = 0.0
testSite = Site(name='LSST')
obsTemp = ObservationMetaData(mjd=mjd, site=testSite)
centerRA, centerDec = _raDecFromAltAz(alt, az, obsTemp)
rotTel = _getRotTelPos(centerRA, centerDec, obsTemp, 0.0)
rotSkyPos = _getRotSkyPos(centerRA, centerDec, obsTemp, rotTel)
obs_metadata = ObservationMetaData(pointingRA=np.degrees(centerRA),
pointingDec=np.degrees(centerDec),
rotSkyPos=np.degrees(rotSkyPos),
bandpassName=bandpass,
mjd=mjd,
boundType = 'circle', boundLength = 2.0*radius,
site=testSite,
m5=m5, seeing=seeing)
moon_alt = -90.0
sun_alt = -90.0
moon_ra, moon_dec = raDecFromAltAz(moon_alt, 0.0, obs_metadata)
dist2moon = haversine(np.radians(moon_ra), np.radians(moon_dec),
obs_metadata._pointingRA, obs_metadata._pointingDec)
obs_metadata.OpsimMetaData = {'moonra': moon_ra,
'moondec': moon_dec,
'moonalt': moon_alt,
'sunalt': sun_alt,
'dist2moon': dist2moon,
'rottelpos': np.degrees(rotTel)}
# Now begin building the database.
# First create the tables.
conn = sqlite3.connect(filename)
c = conn.cursor()
try:
c.execute('''CREATE TABLE galaxy_bulge
(galtileid int, galid int, bra real, bdec real, ra real, dec real, magnorm_bulge real,
sedname_bulge text, a_b real, b_b real, pa_bulge real, bulge_n int,
ext_model_b text, av_b real, rv_b real, u_ab real, g_ab real, r_ab real, i_ab real,
z_ab real, y_ab real, redshift real, BulgeHalfLightRadius real)''')
conn.commit()
except:
raise RuntimeError("Error creating galaxy_bulge table.")
try:
c.execute('''CREATE TABLE galaxy
(galtileid int, galid int, ra real, dec real,
bra real, bdec real, dra real, ddec real,
agnra real, agndec real,
magnorm_bulge, magnorm_disk, magnorm_agn,
sedname_bulge text, sedname_disk text, sedname_agn text,
varParamStr text,
a_b real, b_b real, pa_bulge real, bulge_n int,
a_d real, b_d real, pa_disk real, disk_n int,
ext_model_b text, av_b real, rv_b real,
ext_model_d text, av_d real, rv_d real,
u_ab real, g_ab real, r_ab real, i_ab real,
z_ab real, y_ab real,
redshift real, BulgeHalfLightRadius real, DiskHalfLightRadius real)''')
conn.commit()
except:
raise RuntimeError("Error creating galaxy table.")
try:
c.execute('''CREATE TABLE galaxy_agn
(galtileid int, galid int, agnra real, agndec real, ra real, dec real,
magnorm_agn real, sedname_agn text, varParamStr text, u_ab real,
g_ab real, r_ab real, i_ab real, z_ab real, y_ab real, redshift real)''')
except:
raise RuntimeError("Error creating galaxy_agn table.")
try:
c.execute('''CREATE TABLE StarAllForceseek
(simobjid int, ra real, decl real, magNorm real,
mudecl real, mura real, galacticAv real, vrad real, varParamStr text,
sedFilename text, parallax real, ebv real)''')
except:
raise RuntimeError("Error creating StarAllForceseek table.")
# Now generate the data to be stored in the tables.
rr = rng.random_sample(size)*np.radians(radius)
theta = rng.random_sample(size)*2.0*np.pi
if deltaRA is None:
ra = np.degrees(centerRA + rr*np.cos(theta))
else:
ra = np.degrees(centerRA) + deltaRA
if deltaDec is None:
dec = np.degrees(centerDec + rr*np.sin(theta))
else:
dec = np.degrees(centerDec) + deltaDec
bra = np.radians(ra+rng.random_sample(size)*0.01*radius)
bdec = np.radians(dec+rng.random_sample(size)*0.01*radius)
dra = np.radians(ra + rng.random_sample(size)*0.01*radius)
ddec = np.radians(dec + rng.random_sample(size)*0.01*radius)
agnra = np.radians(ra + rng.random_sample(size)*0.01*radius)
agndec = np.radians(dec + rng.random_sample(size)*0.01*radius)
magnorm_bulge = rng.random_sample(size)*delta_magnorm + magnorm_min
magnorm_disk = rng.random_sample(size)*delta_magnorm + magnorm_min
magnorm_agn = rng.random_sample(size)*delta_magnorm + magnorm_min
b_b = rng.random_sample(size)*0.2
a_b = b_b+rng.random_sample(size)*0.05
b_d = rng.random_sample(size)*0.5
a_d = b_d+rng.random_sample(size)*0.1
BulgeHalfLightRadius = rng.random_sample(size)*0.2
DiskHalfLightRadius = rng.random_sample(size)*0.5
pa_bulge = rng.random_sample(size)*360.0
pa_disk = rng.random_sample(size)*360.0
av_b = rng.random_sample(size)*0.3
av_d = rng.random_sample(size)*0.3
rv_b = rng.random_sample(size)*0.1 + 2.0
rv_d = rng.random_sample(size)*0.1 + 2.0
u_ab = rng.random_sample(size)*4.0 + 17.0
g_ab = rng.random_sample(size)*4.0 + 17.0
r_ab = rng.random_sample(size)*4.0 + 17.0
i_ab = rng.random_sample(size)*4.0 + 17.0
z_ab = rng.random_sample(size)*4.0 + 17.0
y_ab = rng.random_sample(size)*4.0 + 17.0
redshift = rng.random_sample(size)*2.0
t0_mjd = mjd - rng.random_sample(size)*1000.0
agn_tau = rng.random_sample(size)*1000.0 + 1000.0
agnSeed = rng.randint(2, 4001, size=size)
agn_sfu = rng.random_sample(size)
agn_sfg = rng.random_sample(size)
agn_sfr = rng.random_sample(size)
agn_sfi = rng.random_sample(size)
agn_sfz = rng.random_sample(size)
agn_sfy = rng.random_sample(size)
rrStar = rng.random_sample(size)*np.radians(radius)
thetaStar = rng.random_sample(size)*2.0*np.pi
if deltaRA is None:
raStar = centerRA + rrStar*np.cos(thetaStar)
else:
raStar = centerRA + np.radians(deltaRA)
if deltaDec is None:
decStar = centerDec + rrStar*np.sin(thetaStar)
else:
decStar = centerDec + np.radians(deltaDec)
raStar = np.degrees(raStar)
decStar = np.degrees(decStar)
magnormStar = rng.random_sample(size)*delta_magnorm + magnorm_min
mudecl = rng.random_sample(size)*0.0001
mura = rng.random_sample(size)*0.0001
galacticAv = rng.random_sample(size)*0.05*3.1
vrad = rng.random_sample(size)*1.0
parallax = 0.00045+rng.random_sample(size)*0.00001
period = rng.random_sample(size)*20.0
amp = rng.random_sample(size)*5.0
# write the data to the tables.
for i in range(size):
cmd = '''INSERT INTO galaxy_bulge VALUES (%i, %i, %f, %f, %f, %f, %f,
'%s', %f, %f, %f, %i, '%s', %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)''' % \
(i, i, bra[i], bdec[i], ra[i], dec[i], magnorm_bulge[i], galaxy_seds[i%len(galaxy_seds)],
a_b[i], b_b[i], pa_bulge[i], 4, 'CCM', av_b[i], rv_b[i], u_ab[i], g_ab[i],
r_ab[i], i_ab[i], z_ab[i], y_ab[i], redshift[i], BulgeHalfLightRadius[i])
c.execute(cmd)
varParam = {'varMethodName': 'applyAgn',
'pars': {'agn_tau': round(agn_tau[i], 4), 't0_mjd': round(t0_mjd[i], 4),
'agn_sfu': round(agn_sfu[i], 4), 'agn_sfg': round(agn_sfg[i], 4),
'agn_sfr': round(agn_sfr[i], 4), 'agn_sfi': round(agn_sfi[i], 4),
'agn_sfz': round(agn_sfz[i], 4), 'agn_sfy': round(agn_sfy[i], 4),
'seed': int(agnSeed[i])}}
paramStr = json.dumps(varParam)
cmd = '''INSERT INTO galaxy VALUES (%i, %i, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f,
'%s', '%s', '%s', '%s',
%f, %f, %f, %i,
%f, %f, %f, %i,
'%s', %f, %f,
'%s', %f, %f,
%f, %f, %f, %f, %f, %f,
%f, %f, %f)''' % \
(i, i, ra[i], dec[i], bra[i], bdec[i], dra[i], ddec[i], agnra[i], agndec[i],
magnorm_bulge[i], magnorm_disk[i], magnorm_agn[i],
galaxy_seds[i%len(galaxy_seds)], galaxy_seds[i%len(galaxy_seds)], agn_sed,
paramStr,
a_b[i], b_b[i], pa_bulge[i], 4,
a_d[i], b_d[i], pa_disk[i], 1,
'CCM', av_b[i], rv_b[i],
'CCM', av_d[i], rv_d[i],
u_ab[i], g_ab[i], r_ab[i], i_ab[i], z_ab[i], y_ab[i], redshift[i],
BulgeHalfLightRadius[i], DiskHalfLightRadius[i])
c.execute(cmd)
cmd = '''INSERT INTO galaxy_agn VALUES (%i, %i, %f, %f, %f, %f, %f, '%s', '%s',
%f, %f, %f, %f, %f, %f, %f)''' % \
(i, i, agnra[i], agndec[i], ra[i], dec[i],
magnorm_agn[i], agn_sed, paramStr,
u_ab[i], g_ab[i], r_ab[i], i_ab[i],
z_ab[i], y_ab[i], redshift[i])
c.execute(cmd)
varParam = {'varMethodName': 'testVar', 'pars': {'period': period[i], 'amplitude': amp[i]}}
paramStr = json.dumps(varParam)
cmd = '''INSERT INTO StarAllForceseek VALUES (%i, %f, %f, %f, %f, %f, %f, %f, '%s', '%s', %f, %f)''' %\
(i, raStar[i], decStar[i], magnormStar[i], mudecl[i], mura[i],
galacticAv[i], vrad[i], paramStr, star_seds[i%len(star_seds)], parallax[i],
galacticAv[i]/3.1)
c.execute(cmd)
conn.commit()
conn.close()
return obs_metadata
def setRaDecMjd(self,
lon,
lat,
mjd,
degrees=False,
azAlt=False,
solarFlux=130.,
filterNames=['u', 'g', 'r', 'i', 'z', 'y']):
"""
Set the sky parameters by computing the sky conditions on a given MJD and sky location.
lon: Longitude-like (RA or Azimuth). Can be single number, list, or numpy array
lat: Latitude-like (Dec or Altitude)
mjd: Modified Julian Date for the calculation. Must be single number.
degrees: (False) Assumes lon and lat are radians unless degrees=True
azAlt: (False) Assume lon, lat are RA, Dec unless azAlt=True
solarFlux: solar flux in SFU Between 50 and 310. Default=130. 1 SFU=10^4 Jy.
filterNames: list of fitlers to return magnitudes for (if initialized with mags=True).
"""
self.filterNames = filterNames
if self.mags:
self.npix = len(self.filterNames)
# Wrap in array just in case single points were passed
if np.size(lon) == 1:
lon = np.array([lon]).ravel()
lat = np.array([lat]).ravel()
else:
lon = np.array(lon)
lat = np.array(lat)
if degrees:
self.ra = np.radians(lon)
self.dec = np.radians(lat)
else:
self.ra = lon
self.dec = lat
if np.size(mjd) > 1:
raise ValueError('mjd must be single value.')
self.mjd = mjd
if azAlt:
self.azs = self.ra.copy()
self.alts = self.dec.copy()
if self.preciseAltAz:
self.ra, self.dec = _raDecFromAltAz(
self.alts, self.azs,
ObservationMetaData(mjd=self.mjd, site=self.telescope))
else:
self.ra, self.dec = stupidFast_altAz2RaDec(
self.alts, self.azs, self.telescope.latitude_rad,
self.telescope.longitude_rad, mjd)
else:
if self.preciseAltAz:
self.alts, self.azs, pa = _altAzPaFromRaDec(
self.ra, self.dec,
ObservationMetaData(mjd=self.mjd, site=self.telescope))
else:
self.alts, self.azs = stupidFast_RaDec2AltAz(
self.ra, self.dec, self.telescope.latitude_rad,
self.telescope.longitude_rad, mjd)
self.npts = self.ra.size
self._initPoints()
self.solarFlux = solarFlux
self.points['solarFlux'] = self.solarFlux
self._setupPointGrid()
self.paramsSet = True
# Assume large airmasses are the same as airmass=2.5
to_fudge = np.where((self.points['airmass'] > 2.5)
& (self.points['airmass'] < self.airmassLimit))
self.points['airmass'][to_fudge] = 2.499
self.points['alt'][to_fudge] = np.pi / 2 - np.arccos(
1. / self.airmassLimit)
# Interpolate the templates to the set paramters
self._interpSky()
def setRaDecMjd(self,
lon,
lat,
mjd,
degrees=False,
azAlt=False,
solarFlux=130.):
"""
Set the sky parameters by computing the sky conditions on a given MJD and sky location.
Ra and Dec in raidans or degrees.
input ra, dec or az,alt w/ altAz=True
solarFlux: solar flux in s.f.u. Between 50 and 310.
"""
# Wrap in array just in case single points were passed
if not type(lon).__module__ == np.__name__:
if np.size(lon) == 1:
lon = np.array([lon])
lat = np.array([lat])
else:
lon = np.array(lon)
lat = np.array(lat)
if degrees:
self.ra = np.radians(lon)
self.dec = np.radians(lat)
else:
self.ra = lon
self.dec = lat
self.mjd = mjd
if azAlt:
self.azs = self.ra.copy()
self.alts = self.dec.copy()
self.ra, self.dec = _raDecFromAltAz(self.alts, self.azs,
self.Observatory.lon,
self.Observatory.lat, self.mjd)
else:
self.alts, self.azs, pa = _altAzPaFromRaDec(
self.ra, self.dec, self.Observatory.lon, self.Observatory.lat,
self.mjd)
self.npts = self.ra.size
self._initPoints()
self.solarFlux = solarFlux
self.points['solarFlux'] = self.solarFlux
# Switch to Dublin Julian Date for pyephem
self.Observatory.date = mjd2djd(self.mjd)
sun = ephem.Sun()
sun.compute(self.Observatory)
self.sunAlt = sun.alt
self.sunAz = sun.az
# Compute airmass the same way as ESO model
self.airmass = 1. / np.cos(np.pi / 2. - self.alts)
self.points['airmass'] = self.airmass
self.points['nightTimes'] = 2
self.points['alt'] = self.alts
self.points['az'] = self.azs
if self.twilight:
self.points['sunAlt'] = self.sunAlt
self.points['azRelSun'] = wrapRA(self.azs - self.sunAz)
if self.moon:
moon = ephem.Moon()
moon.compute(self.Observatory)
self.moonPhase = moon.phase
self.moonAlt = moon.alt
self.moonAz = moon.az
# Calc azimuth relative to moon
self.azRelMoon = wrapRA(self.azs - self.moonAz)
over = np.where(self.azRelMoon > np.pi)
self.azRelMoon[over] = 2. * np.pi - self.azRelMoon[over]
self.points['moonAltitude'] += np.degrees(self.moonAlt)
self.points['azRelMoon'] += self.azRelMoon
self.points['moonSunSep'] += self.moonPhase / 100. * 180.
if self.zodiacal:
self.eclipLon = np.zeros(self.npts)
self.eclipLat = np.zeros(self.npts)
for i, temp in enumerate(self.ra):
eclip = ephem.Ecliptic(
ephem.Equatorial(self.ra[i], self.dec[i], epoch='2000'))
self.eclipLon[i] += eclip.lon
self.eclipLat[i] += eclip.lat
# Subtract off the sun ecliptic longitude
sunEclip = ephem.Ecliptic(sun)
self.sunEclipLon = sunEclip.lon
self.points['altEclip'] += self.eclipLat
self.points['azEclipRelSun'] += wrapRA(self.eclipLon -
self.sunEclipLon)
lat, ra = hp.pix2ang(nside, np.arange(hp.nside2npix(nside)))
dec = np.pi / 2 - lat
kwargs = dict(twilight=False,
zodiacal=False,
moon=True,
scatteredStar=False,
mergedSpec=False)
sm = sb.SkyModel(observatory='LSST', mags=True) # , **kwargs)
mjd = 49353.177645
sm.setRaDecMjd(ra, dec, mjd)
mag = sm.returnMags()
lmst, last = calcLmstLast(mjd, telescope.longitude_rad)
moonRA, moonDec = _raDecFromAltAz(sm.moonAlt, sm.moonAz,
ObservationMetaData(mjd=mjd, site=telescope))
alt, az, pa = _altAzPaFromRaDec(ra, dec,
ObservationMetaData(mjd=mjd, site=telescope))
angDist2Moon = np.degrees(haversine(az, alt, sm.moonAz, sm.moonAlt))
ang2 = np.degrees(haversine(ra, dec, moonRA, moonDec))
alt = np.degrees(alt)
mags = -0.5 * (np.nanmin(mag['u']) - mag['u'])
#extent = (0,130, 0,90)
extent = (20, 120, 20, 90)
xs, ys = np.mgrid[extent[0]:extent[1], extent[2]:extent[3]]
resampled = griddata((angDist2Moon, alt), mags, (xs, ys))
notInf = np.where((resampled != np.inf) & (~np.isnan(resampled)))
darkTimeMaps = []
for i,indx in enumerate(indices):
skydata,mjd = sb.allSkyDB(dateData[indx]['dateID'], filt=filterName)
if skydata.size > starLimit:
airmass = 1./np.cos(np.radians(90.-skydata['alt']))
skydata = skydata[np.where((airmass < amMax) & (airmass >= 1.))]
alt,az,pa = _altAzPaFromRaDec(np.radians(skydata['ra']), np.radians(skydata['dec']),
telescope.lon, telescope.lat, mjd)
skyhp = healplots.healbin(az,alt, skydata['sky'], nside=nside)
skyhp[np.isnan(skyhp)] = hp.UNSEEN
good = np.where(skyhp != hp.UNSEEN)
sm.setRaDecMjd(hpra[good], hpdec[good], mjd, degrees=False, azAlt=True)
# switch moon to ra dec
moonRA,moonDec = _raDecFromAltAz(sm.moonAlt,sm.moonAz, telescope.lon, telescope.lat, mjd)
# compute distances
moonDistances = haversine(hpra[good], hpdec[good], moonRA,moonDec)
closeToMoon = np.where( moonDistances < np.radians(moonLimit) )
modelhp = np.zeros(npix,dtype=float)+hp.UNSEEN
modelhp[good] = sm.returnMags(canonDict[filterName])
modelhp[good][closeToMoon] = hp.UNSEEN
good = np.where(modelhp != hp.UNSEEN )
validationArr['frameZP'][i] = np.median(modelhp[good]-skyhp[good] )
notnan = np.where(skyhp != hp.UNSEEN)
validationArr['obsDarkestHP'][i] = np.where(skyhp == skyhp[notnan].max() )[0].min()
validationArr['obsBrightestHP'][i] = np.where(skyhp == skyhp[notnan].min() )[0].min()
notnan =np.where(modelhp != hp.UNSEEN)[0]
if notnan.size >=1: