def setUpClass(cls):
try:
cls.sm = sbp.SkyModelPre(speedLoad=True)
mjd = cls.sm.info['mjds'][1] + 4. / 60. / 24.
tmp = cls.sm.returnMags(mjd)
cls.data_present = True
except:
cls.data_present = False
def test_various(self):
"""
Test some various loading things
"""
# check that the sims_data stuff loads
sm = sbp.SkyModelPre(speedLoad=True)
mjd = self.sm.info['mjds'][10]+0.1
mags = sm.returnMags(mjd)
# check that it'll load up something later properly
mags = sm.returnMags(60000)
def setUpClass(cls):
try:
cls.sm = sbp.SkyModelPre(speedLoad=True)
# cls.sm_fields = sbp.SkyModelPre(speedLoad=True, opsimFields=False, useSimsData=False)
mjd = cls.sm.info['mjds'][1]+4./60./24.
tmp = cls.sm.returnMags(mjd)
cls.data_present = True
except:
cls.data_present = False
warnings.warn('Data files not found, skipping tests. Check data/ for instructions to pull data.')
def testReturnMags(self):
"""
Test all the ways ReturnMags can be used
"""
# Check both the healpix and opsim fields
if self.data_present:
sms = [self.sm, sbp.SkyModelPre(speedLoad=True, opsimFields=True)]
mjds = []
for mjd in sms[0].info['mjds'][100:102]:
mjds.append(mjd)
mjds.append(mjd + .0002)
# Make sure there's an mjd that is between sunrise/set that gets tested
diff = sms[0].info['mjds'][1:] - sms[0].info['mjds'][0:-1]
between = np.where(diff >= sms[0].header['timestep_max'])[0][0]
mjds.append(sms[0].info['mjds'][between + 1] +
sms[0].header['timestep_max'])
indxes = [None, [100, 101]]
apply_masks = [True, False]
apply_planets = [True, False]
filters = [['u', 'g', 'r', 'i', 'z', 'y'], ['r']]
for sm in sms:
for mjd in mjds:
for indx in indxes:
for am in apply_masks:
for planet in apply_planets:
for filt in filters:
mags = sm.returnMags(mjd,
indx=indx,
airmass_mask=am,
filters=filt,
planet_mask=planet)
# Check the filters returned are correct
self.assertEqual(len(filt),
len(list(mags.keys())))
self.assertEqual(set(filt),
set(mags.keys()))
airmasses = sm.returnAirmass(mjd,
indx=indx)
# Check the magnitudes are correct
if indx is not None:
self.assertEqual(
np.size(
mags[list(mags.keys())[0]]),
np.size(indx))
self.assertEqual(
np.size(airmasses), np.size(indx))
def obs2sqlite(observations_in, location='LSST', outfile='observations.sqlite', slewtime_limit=5.,
full_sky=False, radians=True):
"""
Utility to take an array of observations and dump it to a sqlite file, filling in useful columns along the way.
observations_in: numpy array with at least columns of
ra : RA in degrees
dec : dec in degrees
mjd : MJD in day
filter : string with the filter name
exptime : the exposure time in seconds
slewtime_limit : float
Consider all slewtimes larger than this to be closed-dome time not part of a slew.
"""
# Set the location to be LSST
if location == 'LSST':
telescope = Site('LSST')
# Check that we have the columns we need
needed_cols = ['ra', 'dec', 'mjd', 'filter']
in_cols = observations_in.dtype.names
for col in needed_cols:
if needed_cols not in in_cols:
ValueError('%s column not found in observtion array' % col)
n_obs = observations_in.size
sm = None
# make sure they are in order by MJD
observations_in.sort(order='mjd')
# Take all the columns that are in the input and add any missing
names = ['filter', 'ra', 'dec', 'mjd', 'exptime', 'alt', 'az', 'skybrightness',
'seeing', 'night', 'slewtime', 'fivesigmadepth', 'airmass', 'sunAlt', 'moonAlt']
types = ['|S1']
types.extend([float]*(len(names)-1))
observations = np.zeros(n_obs, dtype=list(zip(names, types)))
# copy over the ones we have
for col in in_cols:
observations[col] = observations_in[col]
# convert output to be in degrees like expected
if radians:
observations['ra'] = np.degrees(observations['ra'])
observations['dec'] = np.degrees(observations['dec'])
if 'exptime' not in in_cols:
observations['exptime'] = 30.
# Fill in the slewtime. Note that filterchange time gets included in slewtimes
if 'slewtime' not in in_cols:
# Assume MJD is midpoint of exposures
mjd_sec = observations_in['mjd']*24.*3600.
observations['slewtime'][1:] = mjd_sec[1:]-mjd_sec[0:-1] - observations['exptime'][0:-1]*0.5 - observations['exptime'][1:]*0.5
closed = np.where(observations['slewtime'] > slewtime_limit*60.)
observations['slewtime'][closed] = 0.
# Let's just use the stupid-fast to get alt-az
if 'alt' not in in_cols:
alt, az = stupidFast_RaDec2AltAz(np.radians(observations['ra']), np.radians(observations['dec']),
telescope.latitude_rad, telescope.longitude_rad, observations['mjd'])
observations['alt'] = np.degrees(alt)
observations['az'] = np.degrees(az)
# Fill in the airmass
if 'airmass' not in in_cols:
observations['airmass'] = 1./np.cos(np.pi/2. - np.radians(observations['alt']))
# Fill in the seeing
if 'seeing' not in in_cols:
# XXX just fill in a dummy val
observations['seeing'] = 0.8
if 'night' not in in_cols:
m2n = mjd2night()
observations['night'] = m2n(observations['mjd'])
# Sky Brightness
if 'skybrightness' not in in_cols:
if full_sky:
sm = SkyModel(mags=True)
for i, obs in enumerate(observations):
sm.setRaDecMjd(obs['ra'], obs['dec'], obs['mjd'], degrees=True)
observations['skybrightness'][i] = sm.returnMags()[obs['filter']]
else:
# Let's try using the pre-computed sky brighntesses
sm = sb.SkyModelPre(preload=False)
full = sm.returnMags(observations['mjd'][0])
nside = hp.npix2nside(full['r'].size)
imax = float(np.size(observations))
for i, obs in enumerate(observations):
indx = raDec2Hpid(nside, obs['ra'], obs['dec'])
observations['skybrightness'][i] = sm.returnMags(obs['mjd'], indx=[indx])[obs['filter']]
sunMoon = sm.returnSunMoon(obs['mjd'])
observations['sunAlt'][i] = sunMoon['sunAlt']
observations['moonAlt'][i] = sunMoon['moonAlt']
progress = i/imax*100
text = "\rprogress = %.2f%%"%progress
sys.stdout.write(text)
sys.stdout.flush()
observations['sunAlt'] = np.degrees(observations['sunAlt'])
observations['moonAlt'] = np.degrees(observations['moonAlt'])
# 5-sigma depth
for fn in np.unique(observations['filter']):
good = np.where(observations['filter'] == fn)
observations['fivesigmadepth'][good] = m5_flat_sed(fn, observations['skybrightness'][good],
observations['seeing'][good],
observations['exptime'][good],
observations['airmass'][good])
conn = sqlite3.connect(outfile)
df = pd.DataFrame(observations)
df.to_sql('observations', conn)
def __init__(self,
nside=None,
mjd_start=59853.5,
seed=42,
quickTest=True,
alt_min=5.,
lax_dome=True,
cloud_limit=0.3,
sim_ToO=None,
seeing_db=None,
cloud_db=None,
cloud_offset_year=0):
"""
Parameters
----------
nside : int (None)
The healpix nside resolution
mjd_start : float (59853.5)
The MJD to start the observatory up at
alt_min : float (5.)
The minimum altitude to compute models at (degrees).
lax_dome : bool (True)
Passed to observatory model. If true, allows dome creep.
cloud_limit : float (0.3)
The limit to stop taking observations if the cloud model returns something equal or higher
sim_ToO : sim_targetoO object (None)
If one would like to inject simulated ToOs into the telemetry stream.
seeing_db : filename of the seeing data database (None)
If one would like to use an alternate seeing database
cloud_offset_year : float, opt
Offset into the cloud database by 'offset_year' years. Default 0.
cloud_db : filename of the cloud data database (None)
If one would like to use an alternate seeing database
"""
if nside is None:
nside = set_default_nside()
self.nside = nside
self.cloud_limit = cloud_limit
self.alt_min = np.radians(alt_min)
self.lax_dome = lax_dome
self.mjd_start = mjd_start
# Conditions object to update and return on request
self.conditions = Conditions(nside=self.nside)
self.sim_ToO = sim_ToO
# Create an astropy location
self.site = Site('LSST')
self.location = EarthLocation(lat=self.site.latitude,
lon=self.site.longitude,
height=self.site.height)
# Load up all the models we need
mjd_start_time = Time(self.mjd_start, format='mjd')
# Downtime
self.down_nights = []
self.sched_downtime_data = ScheduledDowntimeData(mjd_start_time)
self.unsched_downtime_data = UnscheduledDowntimeData(mjd_start_time)
sched_downtimes = self.sched_downtime_data()
unsched_downtimes = self.unsched_downtime_data()
down_starts = []
down_ends = []
for dt in sched_downtimes:
down_starts.append(dt['start'].mjd)
down_ends.append(dt['end'].mjd)
for dt in unsched_downtimes:
down_starts.append(dt['start'].mjd)
down_ends.append(dt['end'].mjd)
self.downtimes = np.array(list(zip(down_starts, down_ends)),
dtype=list(
zip(['start', 'end'], [float, float])))
self.downtimes.sort(order='start')
# Make sure there aren't any overlapping downtimes
diff = self.downtimes['start'][1:] - self.downtimes['end'][0:-1]
while np.min(diff) < 0:
# Should be able to do this wihtout a loop, but this works
for i, dt in enumerate(self.downtimes[0:-1]):
if self.downtimes['start'][i + 1] < dt['end']:
new_end = np.max([dt['end'], self.downtimes['end'][i + 1]])
self.downtimes[i]['end'] = new_end
self.downtimes[i + 1]['end'] = new_end
good = np.where(
self.downtimes['end'] - np.roll(self.downtimes['end'], 1) != 0)
self.downtimes = self.downtimes[good]
diff = self.downtimes['start'][1:] - self.downtimes['end'][0:-1]
self.seeing_data = SeeingData(mjd_start_time, seeing_db=seeing_db)
self.seeing_model = SeeingModel()
self.seeing_indx_dict = {}
for i, filtername in enumerate(self.seeing_model.filter_list):
self.seeing_indx_dict[filtername] = i
self.cloud_data = CloudData(mjd_start_time,
cloud_db=cloud_db,
offset_year=cloud_offset_year)
sched_logger.info(
f"Using {self.cloud_data.cloud_db} as cloud database with start year {self.cloud_data.start_time.iso}"
)
self.sky_model = sb.SkyModelPre(speedLoad=quickTest)
self.observatory = ExtendedObservatoryModel()
self.observatory.configure_from_module()
# Make it so it respects my requested rotator angles
self.observatory.params.rotator_followsky = True
self.filterlist = ['u', 'g', 'r', 'i', 'z', 'y']
self.seeing_FWHMeff = {}
for key in self.filterlist:
self.seeing_FWHMeff[key] = np.zeros(hp.nside2npix(self.nside),
dtype=float)
self.almanac = Almanac(mjd_start=mjd_start)
# Let's make sure we're at an openable MJD
good_mjd = False
to_set_mjd = mjd_start
while not good_mjd:
good_mjd, to_set_mjd = self.check_mjd(to_set_mjd)
self.mjd = to_set_mjd
self.obsID_counter = 0
def __init__(self, mjd_start=59853.5,
readtime=2., filtername=None, f_change_time=140., shutter_time=1.,
nside=default_nside, sun_limit=-13., quickTest=True, alt_limit=20.,
seed=-1, cloud_limit=0.699, cloud_step=15.,
scheduled_downtime=None, unscheduled_downtime=None,
seeing_model=None, cloud_model=None,
environment=None, filters=None):
"""
Parameters
----------
mjd_start : float (59853.5)
The Modified Julian Date to set the observatory to.
readtime : float (2.)
The time it takes to read out the camera (seconds).
settle : float (2.)
The time it takes the telescope to settle after slewing (seconds)
filtername : str (None)
The filter to start the observatory loaded with
f_change_time : float (120.)
The time it takes to change filters (seconds)
shutter_time : float (1.)
The time it takes to open or close the shutter.
nside : int (32)
The healpixel nside to make sky calculations on.
sun_limit : float (-12.)
The altitude limit for the sun (degrees)
quickTest : bool (True)
Load only a small pre-computed sky array rather than a full year.
seed : float
Random seed to potentially pass to unscheduled downtime
cloud_limit : float (0.699)
Close dome for cloud values over this (traditionally measured in 8ths of the sky?)
cloud_step : float (15.)
Minutes to close if clouds exceed cloud_limit
scheduled_downtime : ScheduledDowntime (None)
The scheduled downtime interface. If None (default) use sims_ocs module.
unscheduled_downtime : UnscheduledDowntime (None)
The unscheduled downtime interface. If None (default) use sims_ocs module.
seeing_model : SeeingModel (None)
The seeing model interface. If None (default) use sims_ocs module.
cloud_model : CloudModel (None)
The cloud model interface. If None (default) use sims_ocs module.
environment : Environment (None)
The environment interface. If None (default) use sims_ocs module.
filters : Filters (None)
The Filters interface. If None (default) use sims_ocs module.
"""
# Make it easy to see what version the object is
self.version = version
self.mjd_start = mjd_start + 0
self.mjd = mjd_start
self.f_change_time = f_change_time
self.readtime = readtime
self.shutter_time = shutter_time
self.sun_limit = np.radians(sun_limit)
self.alt_limit = np.radians(alt_limit)
# Load up the sky brightness model
self.sky = sb.SkyModelPre(speedLoad=quickTest)
# Should realy set this by inspecting the map.
self.sky_nside = 32
# Start out parked
self.ra = None
self.dec = None
self.filtername = None
# Set up all sky coordinates
hpids = np.arange(hp.nside2npix(self.sky_nside))
self.ra_all_sky, self.dec_all_sky = _hpid2RaDec(self.sky_nside, hpids)
self.status = None
self.site = Site(name='LSST')
self.obs = ephem.Observer()
self.obs.lat = self.site.latitude_rad
self.obs.lon = self.site.longitude_rad
self.obs.elevation = self.site.height
self.obs.horizon = 0.
self.sun = ephem.Sun()
self.moon = ephem.Moon()
# Generate sunset times so we can label nights by integers
self.generate_sunsets()
self.night = self.mjd2night(self.mjd)
# Make my dummy time handler
dth = dummy_time_handler(mjd_start)
# Make a slewtime interpolator
self.slew_interp = Slewtime_pre()
# Compute downtimes
self.down_nights = []
if scheduled_downtime is not None:
sdt = scheduled_downtime
else:
sdt = ScheduledDowntime()
sdt.initialize()
if unscheduled_downtime is not None:
usdt = unscheduled_downtime
else:
usdt = UnscheduledDowntime()
usdt.initialize(random_seed=seed)
for downtime in sdt.downtimes:
self.down_nights.extend(range(downtime[0], downtime[0]+downtime[1], 1))
for downtime in usdt.downtimes:
self.down_nights.extend(range(downtime[0], downtime[0]+downtime[1], 1))
self.down_nights.sort()
if seeing_model is not None:
self.seeing_model = seeing_model
else:
self.seeing_model = SeeingSim(dth)
if cloud_model is not None:
self.cloud_model = cloud_model
else:
self.cloud_model = CloudModel(dth)
self.cloud_model.read_data()
self.cloud_limit = cloud_limit
self.cloud_step = cloud_step/60./24.
import numpy as np
import lsst.sims.skybrightness_pre as sb
if __name__ == '__main__':
sm = sb.SkyModelPre(preload=False, verbose=True)
mjd0 = 59031.
stepsize = 10. # 60
mjds = np.arange(mjd0, mjd0+365.25*10+stepsize, stepsize)
for mjd in mjds:
mags = sm.returnMags(mjd)
"""
I think most of these are going to be loading off my spinny disk:
Loading file /Users/yoachim/gitRepos/sims_skybrightness_pre/data/healpix/59194_59407.npz
also loading /Users/yoachim/gitRepos/sims_skybrightness_pre/data/healpix/59194_59407.npy
59194_59407.npz loaded
Loading file /Users/yoachim/gitRepos/sims_skybrightness_pre/data/healpix/59377_59590.npz
also loading /Users/yoachim/gitRepos/sims_skybrightness_pre/data/healpix/59377_59590.npy
59377_59590.npz loaded
Loading file /Users/yoachim/gitRepos/sims_skybrightness_pre/data/healpix/59560_59772.npz
also loading /Users/yoachim/gitRepos/sims_skybrightness_pre/data/healpix/59560_59772.npy
59560_59772.npz loaded
Loading file /Users/yoachim/gitRepos/sims_skybrightness_pre/data/healpix/59743_59955.npz
also loading /Users/yoachim/gitRepos/sims_skybrightness_pre/data/healpix/59743_59955.npy
59743_59955.npz loaded
Loading file /Users/yoachim/gitRepos/sims_skybrightness_pre/data/healpix/59926_60138.npz
also loading /Users/yoachim/gitRepos/sims_skybrightness_pre/data/healpix/59926_60138.npy
def __init__(self,
mjd_start=59580.035,
readtime=2.,
filtername=None,
f_change_time=140.,
nside=default_nside,
sun_limit=-13.,
quickTest=True,
alt_limit=20.,
seed=-1,
cloud_limit=7.,
cloud_step=15.):
"""
Parameters
----------
mjd_start : float (59580.035)
The Modified Julian Date to set the observatory to.
readtime : float (2.)
The time it takes to read out the camera (seconds).
settle : float (2.)
The time it takes the telescope to settle after slewing (seconds)
filtername : str (None)
The filter to start the observatory loaded with
f_change_time : float (120.)
The time it takes to change filters (seconds)
nside : int (32)
The healpixel nside to make sky calculations on.
sun_limit : float (-12.)
The altitude limit for the sun (degrees)
quickTest : bool (True)
Load only a small pre-computed sky array rather than a full year.
seed : float
Random seed to potentially pass to unscheduled downtime
cloud_limit : float (7)
Close dome for cloud values over this (traditionally measured in 8ths of the sky)
cloud_step : float (15.)
Minutes to close if clouds exceed cloud_limit
"""
self.mjd_start = mjd_start + 0
self.mjd = mjd_start
self.f_change_time = f_change_time
self.readtime = readtime
self.sun_limit = np.radians(sun_limit)
self.alt_limit = np.radians(alt_limit)
# Load up the sky brightness model
self.sky = sb.SkyModelPre(preload=False, speedLoad=quickTest)
# Should realy set this by inspecting the map.
self.sky_nside = 32
# Start out parked
self.ra = None
self.dec = None
self.filtername = None
# Set up all sky coordinates
hpids = np.arange(hp.nside2npix(self.sky_nside))
self.ra_all_sky, self.dec_all_sky = _hpid2RaDec(self.sky_nside, hpids)
self.status = None
self.site = Site(name='LSST')
self.obs = ephem.Observer()
self.obs.lat = self.site.latitude_rad
self.obs.lon = self.site.longitude_rad
self.obs.elevation = self.site.height
self.obs.horizon = 0.
self.sun = ephem.Sun()
# Generate sunset times so we can label nights by integers
self.generate_sunsets()
self.night = self.mjd2night(self.mjd)
# Make a slewtime interpolator
self.slew_interp = Slewtime_pre()
# Compute downtimes
self.down_nights = []
sdt = ScheduledDowntime()
sdt.initialize()
usdt = UnscheduledDowntime()
usdt.initialize(random_seed=seed)
for downtime in sdt.downtimes:
self.down_nights.extend(
range(downtime[0], downtime[0] + downtime[1], 1))
for downtime in usdt.downtimes:
self.down_nights.extend(
range(downtime[0], downtime[0] + downtime[1], 1))
self.down_nights.sort()
# Instatiate a seeing model
env_config = Environment()
filter_config = Filters()
self.seeing_model = SeeingModel_no_time()
self.seeing_model.initialize(env_config, filter_config)
self.cloud_model = CloudModel_no_time()
self.cloud_model.initialize()
self.cloud_limit = cloud_limit
self.cloud_step = cloud_step / 60. / 24.