def __init__(self):
TelescopeBase.__init__(self)
self.__slewing = False
self._az = Coord.fromDMS(0)
self._alt = Coord.fromDMS(70)
self._slewing = False
self._tracking = True
self._parked = False
self._abort = threading.Event()
self._epoch = Epoch.J2000
self._cover = False
self._pierside = TelescopePierSide.UNKNOWN
try:
self._site = self.getManager().getProxy("/Site/0")
self._gotSite = True
except:
self._site = Site()
self._gotSite = False
self._setRaDecFromAltAz()
def process():
# session to be used by executor and handlers
session = Session()
task = session.merge(program)
log.debug("[start] %s" % str(task))
site = Site()
nowmjd = site.MJD()
log.debug("[start] Current MJD is %f", nowmjd)
if program.startAt:
waittime = (program.startAt - nowmjd) * 86.4e3
if waittime > 0.0:
log.debug("[start] Waiting until MJD %f to start slewing",
program.startAt)
log.debug("[start] Will wait for %f seconds", waittime)
time.sleep(waittime)
else:
if program.validFor >= 0.0:
if -waittime > program.validFor:
log.debug("[start] Program is not valid anymore",
program.startAt, program.validFor)
self.controller.programComplete(
program, SchedulerStatus.OK,
"Program not valid anymore.")
else:
log.debug(
"[start] Specified slew start MJD %s has already passed; proceeding without waiting",
program.startAt)
else:
log.debug("[start] No slew time specified, so no waiting")
log.debug("[start] Current MJD is %f", site.MJD())
log.debug("[start] Proceeding since MJD %f should have passed",
program.startAt)
self.controller.programBegin(program)
try:
self.executor.execute(task)
log.debug("[finish] %s" % str(task))
self.scheduler.done(task)
self.controller.programComplete(program, SchedulerStatus.OK)
self.state(State.IDLE)
except ProgramExecutionException as e:
self.scheduler.done(task, error=e)
self.controller.programComplete(program, SchedulerStatus.ERROR,
str(e))
self.state(State.IDLE)
log.debug("[error] %s (%s)" % (str(task), str(e)))
except ProgramExecutionAborted as e:
self.scheduler.done(task, error=e)
self.controller.programComplete(program,
SchedulerStatus.ABORTED,
"Aborted by user.")
self.state(State.OFF)
log.debug("[aborted by user] %s" % str(task))
session.commit()
def __init__(self):
TelescopeBase.__init__(self)
self.__slewing = False
self._az = Coord.fromDMS(0)
self._alt = Coord.fromDMS(70)
self._slewing = False
self._tracking = True
self._parked = False
self._abort = threading.Event()
self._epoch = Epoch.J2000
self._cover = False
self._pierside = TelescopePierSide.UNKNOWN
try:
self._site = self.getManager().getProxy("/Site/0")
self._gotSite = True
except:
self._site = Site()
self._gotSite = False
self._setRaDecFromAltAz()
def __init__(self):
ChimeraObject.__init__(self)
self.__slewing = False
self._az = Coord.fromDMS(0)
self._alt = Coord.fromDMS(70)
self._slewing = False
self._tracking = True
self._parked = False
self._abort = threading.Event()
try:
self._site = self.getManager().getProxy(self['site'])
self._gotSite = True
except:
self._site = Site()
self._gotSite = False
self._setRaDecFromAltAz()
def __init__(self):
TelescopeBase.__init__(self)
self.__slewing = False
self._az = Coord.fromDMS(0)
self._alt = Coord.fromDMS(70)
self._slewing = False
self._tracking = True
self._parked = False
self._abort = threading.Event()
try:
self._site = self.getManager().getProxy("/Site/0")
self._gotSite = True
except:
self._site = Site()
self._gotSite = False
self._setRaDecFromAltAz()
def setJD(self, jd=None):
'''
Configure time domain by specifing a julian day. It will use information on exposure time to build time bins that will be
filled when selecting targets.
'''
if not jd:
site = Site()
jd = np.floor(site.JD()) + 0.5
nightstart = _skysub.jd_sun_alt(self.sunMaxAlt, jd, self.sitelat,
self.sitelong)
nightend = _skysub.jd_sun_alt(self.sunMaxAlt, jd + 0.5, self.sitelat,
self.sitelong)
log.debug('Nigh Start @JD= %.3f # Night End @JD = %.3f' %
(nightstart, nightend))
tbin = np.max([np.max(self.sciExpTime),
np.max(self.stdExpTime)
]) * self.nfilters / 60. / 60. / 24.
self.obsTimeBins = np.arange(nightstart, nightend + tbin, tbin)
self.obsTimeMask = np.zeros(len(self.obsTimeBins))
self.obsTimeMask[-1] = 1.0
# Marking filled bins
session = Session()
scheduled = session.query(Program)
for target in scheduled:
tindex = np.abs(self.obsTimeBins - 2400000.5 -
target.slewAt).argmin()
self.obsTimeMask[tindex] = 1.0
self.isJD = True
def __init__(self):
ChimeraObject.__init__(self)
self._thesky = None
self._telescope = None
self._term = threading.Event()
self._idle_time = 0.2
self._target = None
try:
self._site = self.getManager().getProxy(self['site'])
self._gotSite = True
except:
self._site = Site()
self._gotSite = False
def __init__(self):
TelescopeBase.__init__(self)
self.__slewing = False
self._az = Coord.fromDMS(0)
self._alt = Coord.fromDMS(70)
self._slewing = False
self._tracking = True
self._parked = False
self._abort = threading.Event()
try:
self._site = self.getManager().getProxy("/Site/0")
self._gotSite = True
except:
self._site = Site()
self._gotSite = False
self._setRaDecFromAltAz()
if (zeta > -2. * pi) and (zeta < 2. * pi):
if self.site_latitude.R <= 0.:
zeta += pi
else:
zeta = telaz
if zeta < 0:
zeta = zeta + 2 * pi
elif zeta > 2 * pi:
zeta - 2 * pi
return zeta * 180 / pi
if __name__ == '__main__':
import numpy as np
dome_radius, mount_dec_height, mount_dec_length, mount_dec_offset = 147, 0, 49.2, 0
site = Site()
Model = AzimuthModel(site['latitude'], dome_radius, mount_dec_height,
mount_dec_length, mount_dec_offset)
# for dra in np.arange(10, 200, 36):
# for ddec in np.arange(1, 360, 10):
for az, alt in [(ii, jj) for ii in np.arange(5, 360, 10)
for jj in np.arange(25, 90, 20)]:
tel_pos = Position.altAzToRaDec(
Position.fromAltAz(Coord.fromD(alt), Coord.fromD(az)),
site['latitude'], site.LST())
model = Model.solve_dome_azimuth(tel_pos, site.LST_inRads())
print 'here', alt, az, model, model - az
class FakeTelescope (TelescopeBase, TelescopeCover, TelescopePier):
def __init__(self):
TelescopeBase.__init__(self)
self.__slewing = False
self._az = Coord.fromDMS(0)
self._alt = Coord.fromDMS(70)
self._slewing = False
self._tracking = True
self._parked = False
self._abort = threading.Event()
self._epoch = Epoch.J2000
self._cover = False
self._pierside = TelescopePierSide.UNKNOWN
try:
self._site = self.getManager().getProxy("/Site/0")
self._gotSite = True
except:
self._site = Site()
self._gotSite = False
self._setRaDecFromAltAz()
def _getSite(self):
if self._gotSite:
self._site._transferThread()
return self._site
else:
try:
self._site = self.getManager().getProxy("/Site/0")
self._gotSite = True
except:
pass
return self._site
def _setRaDecFromAltAz(self):
raDec = self._getSite().altAzToRaDec(
Position.fromAltAz(self._alt, self._az))
self._ra = raDec.ra
self._dec = raDec.dec
def _setAltAzFromRaDec(self):
altAz = self._getSite().raDecToAltAz(
Position.fromRaDec(self._ra, self._dec))
self._alt = altAz.alt
self._az = altAz.az
def __start__(self):
self.setHz(1)
@lock
def control(self):
self._getSite()
if not self._slewing:
if self._tracking:
self._setAltAzFromRaDec()
try:
self._validateAltAz(self.getPositionAltAz())
except ObjectTooLowException, msg:
self.log.exception(msg)
self._stopTracking()
self.trackingStopped(self.getPositionRaDec(),TelescopeStatus.OBJECT_TOO_LOW)
else:
self._setRaDecFromAltAz()
return True
class FakeTelescope (TelescopeBase):
def __init__(self):
TelescopeBase.__init__(self)
self.__slewing = False
self._az = Coord.fromDMS(0)
self._alt = Coord.fromDMS(70)
self._slewing = False
self._tracking = True
self._parked = False
self._abort = threading.Event()
try:
self._site = self.getManager().getProxy("/Site/0")
self._gotSite = True
except:
self._site = Site()
self._gotSite = False
self._setRaDecFromAltAz()
def _getSite(self):
if self._gotSite:
self._site._transferThread()
return self._site
else:
try:
self._site = self.getManager().getProxy("/Site/0")
self._gotSite = True
except:
pass
return self._site
def _setRaDecFromAltAz(self):
raDec = self._getSite().altAzToRaDec(
Position.fromAltAz(self._alt, self._az))
self._ra = raDec.ra
self._dec = raDec.dec
def _setAltAzFromRaDec(self):
altAz = self._getSite().raDecToAltAz(
Position.fromRaDec(self._ra, self._dec))
self._alt = altAz.alt
self._az = altAz.az
def __start__(self):
self.setHz(1)
@lock
def control(self):
self._getSite()
if not self._slewing:
if self._tracking:
self._setAltAzFromRaDec()
else:
self._setRaDecFromAltAz()
return True
def slewToRaDec(self, position):
if not isinstance(position, Position):
position = Position.fromRaDec(
position[0], position[1], epoch=Epoch.J2000)
self._validateRaDec(position)
self.slewBegin(position)
ra_steps = position.ra - self.getRa()
ra_steps = float(ra_steps / 10.0)
dec_steps = position.dec - self.getDec()
dec_steps = float(dec_steps / 10.0)
self._slewing = True
self._abort.clear()
status = TelescopeStatus.OK
t = 0
while t < 5:
if self._abort.isSet():
self._slewing = False
status = TelescopeStatus.ABORTED
break
self._ra += ra_steps
self._dec += dec_steps
self._setAltAzFromRaDec()
time.sleep(0.5)
t += 0.5
self._slewing = False
self.slewComplete(self.getPositionRaDec(), status)
@lock
def slewToAltAz(self, position):
if not isinstance(position, Position):
position = Position.fromAltAz(*position)
self._validateAltAz(position)
self.slewBegin(self._getSite().altAzToRaDec(position))
alt_steps = position.alt - self.getAlt()
alt_steps = float(alt_steps / 10.0)
az_steps = position.az - self.getAz()
az_steps = float(az_steps / 10.0)
self._slewing = True
self._abort.clear()
status = TelescopeStatus.OK
t = 0
while t < 5:
if self._abort.isSet():
self._slewing = False
status = TelescopeStatus.ABORTED
break
self._alt += alt_steps
self._az += az_steps
self._setRaDecFromAltAz()
time.sleep(0.5)
t += 0.5
self._slewing = False
self.slewComplete(self.getPositionRaDec(), status)
def abortSlew(self):
self._abort.set()
while self.isSlewing():
time.sleep(0.1)
self._slewing = False
def isSlewing(self):
return self._slewing
@lock
def moveEast(self, offset, rate=SlewRate.MAX):
self._slewing = True
pos = self.getPositionRaDec()
pos = Position.fromRaDec(pos.ra + Coord.fromAS(offset), pos.dec)
self.slewBegin(pos)
self._ra += Coord.fromAS(offset)
self._setAltAzFromRaDec()
self._slewing = False
self.slewComplete(self.getPositionRaDec(), TelescopeStatus.OK)
@lock
def moveWest(self, offset, rate=SlewRate.MAX):
self._slewing = True
pos = self.getPositionRaDec()
pos = Position.fromRaDec(pos.ra + Coord.fromAS(-offset), pos.dec)
self.slewBegin(pos)
self._ra += Coord.fromAS(-offset)
self._setAltAzFromRaDec()
self._slewing = False
self.slewComplete(self.getPositionRaDec(), TelescopeStatus.OK)
@lock
def moveNorth(self, offset, rate=SlewRate.MAX):
self._slewing = True
pos = self.getPositionRaDec()
pos = Position.fromRaDec(pos.ra, pos.dec + Coord.fromAS(offset))
self.slewBegin(pos)
self._dec += Coord.fromAS(offset)
self._setAltAzFromRaDec()
self._slewing = False
self.slewComplete(self.getPositionRaDec(), TelescopeStatus.OK)
@lock
def moveSouth(self, offset, rate=SlewRate.MAX):
self._slewing = True
pos = self.getPositionRaDec()
pos = Position.fromRaDec(pos.ra, pos.dec + Coord.fromAS(-offset))
self.slewBegin(pos)
self._dec += Coord.fromAS(-offset)
self._setAltAzFromRaDec()
self._slewing = False
self.slewComplete(self.getPositionRaDec(), TelescopeStatus.OK)
@lock
def getRa(self):
return self._ra
@lock
def getDec(self):
return self._dec
@lock
def getAz(self):
return self._az
@lock
def getAlt(self):
return self._alt
@lock
def getPositionRaDec(self):
return Position.fromRaDec(self.getRa(), self.getDec())
@lock
def getPositionAltAz(self):
return Position.fromAltAz(self.getAlt(), self.getAz())
@lock
def getTargetRaDec(self):
return Position.fromRaDec(self.getRa(), self.getDec())
@lock
def getTargetAltAz(self):
return Position.fromAltAz(self.getAlt(), self.getAz())
@lock
def syncRaDec(self, position):
if not isinstance(position, Position):
position = Position.fromRaDec(*position)
self._ra = position.ra
self._dec = position.dec
@lock
def park(self):
self.log.info("Parking...")
self._parked = True
self.parkComplete()
@lock
def unpark(self):
self.log.info("Unparking...")
self._parked = False
self.unparkComplete()
def isParked(self):
return self._parked
@lock
def startTracking(self):
self._tracking = True
@lock
def stopTracking(self):
self._tracking = False
def isTracking(self):
return self._tracking
class FakeTelescope(ChimeraObject, ITelescopeDriverSlew, ITelescopeDriverSync,
ITelescopeDriverPark, ITelescopeDriverTracking):
__config__ = {'site': '/Site/0'}
def __init__(self):
ChimeraObject.__init__(self)
self.__slewing = False
self._az = Coord.fromDMS(0)
self._alt = Coord.fromDMS(70)
self._slewing = False
self._tracking = True
self._parked = False
self._abort = threading.Event()
try:
self._site = self.getManager().getProxy(self['site'])
self._gotSite = True
except:
self._site = Site()
self._gotSite = False
self._setRaDecFromAltAz()
def _getSite(self):
if self._gotSite:
self._site._transferThread()
return self._site
else:
try:
self._site = self.getManager().getProxy(self['site'])
self._gotSite = True
except:
pass
return self._site
def _setRaDecFromAltAz(self):
raDec = self._getSite().altAzToRaDec(
Position.fromAltAz(self._alt, self._az))
self._ra = raDec.ra
self._dec = raDec.dec
def _setAltAzFromRaDec(self):
altAz = self._getSite().raDecToAltAz(
Position.fromRaDec(self._ra, self._dec))
self._alt = altAz.alt
self._az = altAz.az
def __start__(self):
self.setHz(1)
@lock
def control(self):
self._getSite()
if not self._slewing:
if self._tracking:
self._setAltAzFromRaDec()
else:
self._setRaDecFromAltAz()
return True
def open(self):
pass
def close(self):
pass
def ping(self):
pass
@lock
def slewToRaDec(self, position):
self.slewBegin(position)
ra_steps = position.ra - self.getRa()
ra_steps = float(ra_steps / 10.0)
dec_steps = position.dec - self.getDec()
dec_steps = float(dec_steps / 10.0)
self._slewing = True
self._abort.clear()
t = 0
while t < 5:
if self._abort.isSet():
self._slewing = False
return
self._ra += ra_steps
self._dec += dec_steps
self._setAltAzFromRaDec()
time.sleep(0.5)
t += 0.5
self._slewing = False
self.slewComplete(self.getPositionRaDec())
@lock
def slewToAltAz(self, position):
self.slewBegin(self._getSite().altAzToRaDec(position))
alt_steps = position.alt - self.getAlt()
alt_steps = float(alt_steps / 10.0)
az_steps = position.az - self.getAz()
az_steps = float(az_steps / 10.0)
self._slewing = True
self._abort.clear()
t = 0
while t < 5:
if self._abort.isSet():
self._slewing = False
return
self._alt += alt_steps
self._az += az_steps
self._setRaDecFromAltAz()
time.sleep(0.5)
t += 0.5
self._slewing = False
self.slewComplete(self.getPositionRaDec())
def isSlewing(self):
return self._slewing
def abortSlew(self):
self._abort.set()
while self.isSlewing():
time.sleep(0.1)
self.abortComplete(self.getPositionRaDec())
@lock
def moveEast(self, offset, rate=SlewRate.MAX):
pass
@lock
def moveWest(self, offset, rate=SlewRate.MAX):
pass
@lock
def moveNorth(self, offset, rate=SlewRate.MAX):
pass
@lock
def moveSouth(self, offset, rate=SlewRate.MAX):
pass
def getRa(self):
return self._ra
def getDec(self):
return self._dec
def getAz(self):
return self._az
def getAlt(self):
return self._alt
def getPositionRaDec(self):
return Position.fromRaDec(self.getRa(), self.getDec())
def getPositionAltAz(self):
return Position.fromAltAz(self.getAlt(), self.getAz())
def getTargetRaDec(self):
return Position.fromRaDec(self.getRa(), self.getDec())
def getTargetAltAz(self):
return Position.fromAltAz(self.getAlt(), self.getAz())
#GUI Compatibility methods
def getAlignMode(self):
return self['align_mode']
def getLat(self):
return self._getSite()['latitude']
def getLong(self):
return self._getSite()['longitude']
def getDate(self):
return self._getSite().ut()
def getLocalTime(self):
return self._getSite().localtime()
def getUTCOffset(self):
return self._getSite()['utc_offset']
def getLocalSiderealTime(self):
return self._getSite().LST()
def getCurrentTrackingRate(self):
pass
@lock
def sync(self, position):
self._ra = position.ra
self._dec = position.dec
@lock
def park(self):
self._parked = True
@lock
def unpark(self):
self._parked = False
def isParked(self):
return self._parked
@lock
def setParkPosition(self, position):
pass
def startTracking(self):
self._tracking = True
def stopTracking(self):
self._tracking = False
def isTracking(self):
return self._tracking
class FakeTelescope(TelescopeBase, TelescopeCover, TelescopePier):
def __init__(self):
TelescopeBase.__init__(self)
self.__slewing = False
self._az = Coord.fromDMS(0)
self._alt = Coord.fromDMS(70)
self._slewing = False
self._tracking = True
self._parked = False
self._abort = threading.Event()
self._epoch = Epoch.J2000
self._cover = False
self._pierside = TelescopePierSide.UNKNOWN
try:
self._site = self.getManager().getProxy("/Site/0")
self._gotSite = True
except:
self._site = Site()
self._gotSite = False
self._setRaDecFromAltAz()
def _getSite(self):
if self._gotSite:
self._site._transferThread()
return self._site
else:
try:
self._site = self.getManager().getProxy("/Site/0")
self._gotSite = True
except:
pass
return self._site
def _setRaDecFromAltAz(self):
raDec = self._getSite().altAzToRaDec(
Position.fromAltAz(self._alt, self._az))
self._ra = raDec.ra
self._dec = raDec.dec
def _setAltAzFromRaDec(self):
altAz = self._getSite().raDecToAltAz(
Position.fromRaDec(self._ra, self._dec))
self._alt = altAz.alt
self._az = altAz.az
def __start__(self):
self.setHz(1)
@lock
def control(self):
self._getSite()
if not self._slewing:
if self._tracking:
self._setAltAzFromRaDec()
try:
self._validateAltAz(self.getPositionAltAz())
except ObjectTooLowException, msg:
self.log.exception(msg)
self._stopTracking()
self.trackingStopped(self.getPositionRaDec(),
TelescopeStatus.OBJECT_TOO_LOW)
else:
self._setRaDecFromAltAz()
return True
class FakeTelescope(TelescopeBase, TelescopeCover, TelescopePier):
def __init__(self):
TelescopeBase.__init__(self)
self.__slewing = False
self._az = Coord.fromDMS(0)
self._alt = Coord.fromDMS(70)
self._slewing = False
self._tracking = True
self._parked = False
self._abort = threading.Event()
self._epoch = Epoch.J2000
self._cover = False
self._pierside = TelescopePierSide.UNKNOWN
try:
self._site = self.getManager().getProxy("/Site/0")
self._gotSite = True
except:
self._site = Site()
self._gotSite = False
self._setRaDecFromAltAz()
def _getSite(self):
if self._gotSite:
self._site._transferThread()
return self._site
else:
try:
self._site = self.getManager().getProxy("/Site/0")
self._gotSite = True
except:
pass
return self._site
def _setRaDecFromAltAz(self):
raDec = self._getSite().altAzToRaDec(
Position.fromAltAz(self._alt, self._az))
self._ra = raDec.ra
self._dec = raDec.dec
def _setAltAzFromRaDec(self):
altAz = self._getSite().raDecToAltAz(
Position.fromRaDec(self._ra, self._dec))
self._alt = altAz.alt
self._az = altAz.az
def __start__(self):
self.setHz(1)
@lock
def control(self):
self._getSite()
if not self._slewing:
if self._tracking:
self._setAltAzFromRaDec()
try:
self._validateAltAz(self.getPositionAltAz())
except ObjectTooLowException as msg:
self.log.exception(msg)
self._stopTracking()
self.trackingStopped(self.getPositionRaDec(),
TelescopeStatus.OBJECT_TOO_LOW)
else:
self._setRaDecFromAltAz()
return True
def slewToRaDec(self, position):
if not isinstance(position, Position):
position = Position.fromRaDec(position[0],
position[1],
epoch=Epoch.J2000)
self._validateRaDec(position)
self.slewBegin(position)
ra_steps = position.ra - self.getRa()
ra_steps = float(ra_steps / 10.0)
dec_steps = position.dec - self.getDec()
dec_steps = float(dec_steps / 10.0)
self._slewing = True
self._epoch = position.epoch
self._abort.clear()
status = TelescopeStatus.OK
t = 0
while t < 5:
if self._abort.isSet():
self._slewing = False
status = TelescopeStatus.ABORTED
break
self._ra += ra_steps
self._dec += dec_steps
self._setAltAzFromRaDec()
time.sleep(0.5)
t += 0.5
self._slewing = False
self.startTracking()
self.slewComplete(self.getPositionRaDec(), status)
@lock
def slewToAltAz(self, position):
if not isinstance(position, Position):
position = Position.fromAltAz(*position)
self._validateAltAz(position)
self.slewBegin(self._getSite().altAzToRaDec(position))
alt_steps = position.alt - self.getAlt()
alt_steps = float(alt_steps / 10.0)
az_steps = position.az - self.getAz()
az_steps = float(az_steps / 10.0)
self._slewing = True
self._abort.clear()
status = TelescopeStatus.OK
t = 0
while t < 5:
if self._abort.isSet():
self._slewing = False
status = TelescopeStatus.ABORTED
break
self._alt += alt_steps
self._az += az_steps
self._setRaDecFromAltAz()
time.sleep(0.5)
t += 0.5
self._slewing = False
self.slewComplete(self.getPositionRaDec(), status)
def abortSlew(self):
self._abort.set()
while self.isSlewing():
time.sleep(0.1)
self._slewing = False
def isSlewing(self):
return self._slewing
@lock
def moveEast(self, offset, rate=SlewRate.MAX):
self._slewing = True
pos = self.getPositionRaDec()
pos = Position.fromRaDec(pos.ra + Coord.fromAS(offset), pos.dec)
self.slewBegin(pos)
self._ra += Coord.fromAS(offset)
self._setAltAzFromRaDec()
self._slewing = False
self.slewComplete(self.getPositionRaDec(), TelescopeStatus.OK)
@lock
def moveWest(self, offset, rate=SlewRate.MAX):
self._slewing = True
pos = self.getPositionRaDec()
pos = Position.fromRaDec(pos.ra + Coord.fromAS(-offset), pos.dec)
self.slewBegin(pos)
self._ra += Coord.fromAS(-offset)
self._setAltAzFromRaDec()
self._slewing = False
self.slewComplete(self.getPositionRaDec(), TelescopeStatus.OK)
@lock
def moveNorth(self, offset, rate=SlewRate.MAX):
self._slewing = True
pos = self.getPositionRaDec()
pos = Position.fromRaDec(pos.ra, pos.dec + Coord.fromAS(offset))
self.slewBegin(pos)
self._dec += Coord.fromAS(offset)
self._setAltAzFromRaDec()
self._slewing = False
self.slewComplete(self.getPositionRaDec(), TelescopeStatus.OK)
@lock
def moveSouth(self, offset, rate=SlewRate.MAX):
self._slewing = True
pos = self.getPositionRaDec()
pos = Position.fromRaDec(pos.ra, pos.dec + Coord.fromAS(-offset))
self.slewBegin(pos)
self._dec += Coord.fromAS(-offset)
self._setAltAzFromRaDec()
self._slewing = False
self.slewComplete(self.getPositionRaDec(), TelescopeStatus.OK)
@lock
def getRa(self):
return self._ra
@lock
def getDec(self):
return self._dec
@lock
def getAz(self):
return self._az
@lock
def getAlt(self):
return self._alt
@lock
def getPositionRaDec(self):
return Position.fromRaDec(self.getRa(),
self.getDec(),
epoch=self._epoch)
@lock
def getPositionAltAz(self):
return Position.fromAltAz(self.getAlt(), self.getAz())
@lock
def getTargetRaDec(self):
return Position.fromRaDec(self.getRa(), self.getDec())
@lock
def getTargetAltAz(self):
return Position.fromAltAz(self.getAlt(), self.getAz())
@lock
def syncRaDec(self, position):
if not isinstance(position, Position):
position = Position.fromRaDec(*position)
self._ra = position.ra
self._dec = position.dec
@lock
def park(self):
self.log.info("Parking...")
self._parked = True
self.parkComplete()
@lock
def unpark(self):
self.log.info("Unparking...")
self._parked = False
self.unparkComplete()
def isParked(self):
return self._parked
@lock
def startTracking(self):
self._tracking = True
self.trackingStarted(self.getPositionRaDec())
@lock
def stopTracking(self):
self._stopTracking()
self.trackingStopped(self.getPositionRaDec(), TelescopeStatus.ABORTED)
def _stopTracking(self):
self._tracking = False
def isTracking(self):
return self._tracking
def openCover(self):
self._cover = True
def closeCover(self):
self._cover = False
def isCoverOpen(self):
return self._cover
def setPierSide(self, side):
self._pierside = side
def getPierSide(self):
return self._pierside
def selectStandardTargets(self,flag,nstars=3,nairmass=3):
'''
Based on configuration parameters, select 'nstars' standard stars to run scheduler on a specified Julian Day. Ideally you
will select standard stars before your science targets so not to have a full queue. Usually standard stars are observed
more than once a night at different airmasses. The user can control this parameter with nairmass and the script will try
to take care of the rest.
'''
session = Session()
# query project information
projQuery = session.query(Projects).filter(Projects.flag == flag)
totobstime = 0.
# Calculate total observation time
for block in projQuery:
totobstime += block.exptime
totobstime /= 86400.0
# First of all, standard stars can be observed multiple times in sucessive nights. I will mark all
# stars as unscheduled.
targets = session.query(Targets).filter(Targets.scheduled == True).filter(Targets.type == flag)
for target in targets:
target.scheduled = False
session.commit()
# [To be done] Reject objects that are close to the moon
# [To be done] Apply all sorts of rejections
# Selecting standard stars is not only searching for the higher in that time but select stars than can be observed at 3
# or more (nairmass) different airmasses. It is also important to select stars with different colors (but this will be
# taken care in the future).
if nairmass*nstars > len(self.obsTimeBins):
self.log.warning('Requesting more stars/observations than it will be possible to schedule. Decreasing number of requests to fit in the night.')
nstars = len(self.obsTimeBins)/nairmass
# Build a grid of desired times for higher airmass observation of each standard star.
stdObsTimeBin = np.arange(10,len(self.obsTimeBins)-10,(len(self.obsTimeBins)-10)/nstars)
obsStandars = np.zeros(nstars)
print stdObsTimeBin
# selecting the closest bin without observation
stdObsTimeBin,status = self.findSuitableTimeBin(stdObsTimeBin)
if status != 0:
raise Exception('Could not find suitable time to start observations! Try cleaning queue.')
print stdObsTimeBin
site = Site()
calclst = lambda time: np.sum(np.array([float(tt) / 60.**i for i,tt in enumerate(str(site._getEphem(datetimeFromJD(time)).sidereal_time()).split(':'))]))
nightlst = np.array([calclst(obstime) for obstime in self.obsTimeBins])
for i,tbin in enumerate(stdObsTimeBin):
# selecting the closest bin without observation
closestcleanbin = tbin
while self.obsTimeMask[closestcleanbin] > 0.0:
closestcleanbin += 1
if i+1 < len(stdObsTimeBin):
if closestcleanbin > stdObsTimeBin[i+1]:
raise Exception('Could not find suitable place to start observations of standard star. Try cleaning queue.')
time = self.obsTimeBins[closestcleanbin]
# 1 - Select objects from database that where not scheduled yet (standard stars may be repited)
# that fits our observing night
#targetSched = False
# Will try until a good match is obtained
#while( not targetSched ):
targets = session.query(Targets).filter(Targets.scheduled == 0).filter(Targets.type == flag)
if len(targets[:]) > 0:
#ephem = site._getEphem(datetimeFromJD(time))
lst = calclst(time) #np.sum(np.array([float(tt) / 60.**i for i,tt in enumerate(str(ephem.sidereal_time()).split(':'))]))
sitelat = np.sum(np.array([float(tt) / 60.**i for i,tt in enumerate(str(site['latitude']).split(':'))]))
alt = np.array([_skysub.altit(target.targetDec,lst - target.targetRa,sitelat)[0] for target in targets])
stg = alt.argmax()
print('Selecting %s'%(targets[stg]))
# Marking target as schedule
tst = session.query(Targets).filter(Targets.id == targets[stg].id)
# Build airmass table for object
objsecz = np.array([_skysub.true_airmass(_skysub.secant_z(_skysub.altit(targets[stg].targetDec,nlst - targets[stg].targetRa,sitelat)[0])) for nlst in nightlst])
# Build desired airmass table
#obsairmass = np.linspace(_skysub.true_airmass(_skysub.secant_z(alt[stg])),projQuery[0].maxairmass,nairmass)
obsairmass = np.logspace(np.log10(np.min(objsecz[objsecz > 0])),np.log10(projQuery[0].maxairmass),nairmass)
np.savetxt('airmass_%04i.dat'%(stg),X=zip(self.obsTimeBins,objsecz))
# Build mask with scheduled airmasses
#mask = np.zeros(len(objsecz),dtype=bool) == 1
pltobstime,pltobsairmass = np.array([]),np.array([])
# Try scheduling observations on all airmasses
for airmass in obsairmass:
# Get times where the object is close to the desired airmass and there are no observations scheduled
timeobsmask = np.bitwise_and(self.obsTimeMask < 1.0,np.abs(objsecz - airmass) < self.tolairmass)
# Check that there are times available
if not timeobsmask.any():
#raise Exception('No time available for scheduling observations of standard star %s at airmass %.3f'%(targets[stg],airmass))
self.log.warning('No time available for scheduling observations of standard star %s at airmass %.3f'%(targets[stg],airmass))
# Start trying to schedule observations
indexes = np.arange(len(self.obsTimeMask))[timeobsmask] #np.bitwise_and(self.obsTimeMask, timeobsmask)
obsSched = False
for index in indexes:
print('[%.3f] - Time bin available for observation of standard star at airmass %.3f'%(self.obsTimeBins[index], airmass))
print '- Require %i extra time bins'%(totobstime/self.tbin)
if (self.obsTimeMask[index:index+totobstime/self.tbin] < 1.0).all():
print 'Observation fit in this block.'
self.obsTimeMask[index:index+totobstime/self.tbin] = 1.0
self.log.info('Requesting observations of %s @airmass=%4.2f @mjd=%.3f...'%(target.name,airmass,self.obsTimeBins[index]-2400000.5))
pltobstime = np.append(pltobstime,self.obsTimeBins[index:index+totobstime/self.tbin])
pltobsairmass = np.append(pltobsairmass, objsecz[index:index+totobstime/self.tbin])
#for nblock,ii in enumerate(range(index,int(index+totobstime/self.tbin),1)):
self.addObservation(targets[stg],self.obsTimeBins[index],projQuery)
break
np.savetxt('obsairmass_%04i.dat'%stg,X = zip(pltobstime,pltobsairmass))
#self.obsTimeMask[index] = 1.0
#for iobsbins in range(index+1,index+int(totobstime/self.tbin)):
#print '[%i] - require extra time bin'%(iobsbins)
#if self.obsTimeMask[iobsbins] < 1.0:
# self.obsTimeMask[iobsbins] = 1.0
#else:
# raise Exception('Time bin [%i/%i] not available for observation of standard star at airmass %.3f'%(iobsbins,len(self.obsTimeMask),airmass))
#else:
#raise Exception('Time bin not available for observation of standard star at airmass %.3f'%(airmass))
for t in tst:
t.scheduled = True
session.commit()
obsStandars[i] = t.id
else:
self.log.warning('No suitable standard star for jd:%.3f in database...'%(time))
return 0
return 0
if len(obsStandars[obsStandars >= 0]) < nstars:
self.log.warning('Could not find %i suitable standard stars in catalog. Only %i where found.'%(nstars,len(obsStandars[obsStandars >= 0])))
obsStandars = np.zeros(len(self.obsTimeBins))-1 # first selection of observable standards
for tbin,time in enumerate(self.obsTimeBins):
if self.obsTimeMask[tbin] < 1.0:
# 1 - Select objects from database that where not scheduled yet (standard stars may be repited)
# that fits our observing night
targets = session.query(Targets).filter(Targets.scheduled == 0).filter(Targets.type == flag)
if len(targets[:]) > 0:
ephem = site._getEphem(datetimeFromJD(time))
lst = np.sum(np.array([float(tt) / 60.**i for i,tt in enumerate(str(ephem.sidereal_time()).split(':'))]))
sitelat = np.sum(np.array([float(tt) / 60.**i for i,tt in enumerate(str(site['latitude']).split(':'))]))
secz = np.array([_skysub.secant_z(_skysub.altit(target.targetDec,lst - target.targetRa,sitelat)[0]) for target in targets])
stg = secz.argmax()
self.log.info('Selecting %s'%(targets[stg]))
# Marking target as schedule
tst = session.query(Targets).filter(Targets.id == targets[stg].id)
for t in tst:
t.scheduled = True
session.commit()
obsStandars[tbin] = t.id
else:
print('No suitable target for jd:%.3f in database...'%(time))
break
else:
self.log.info('Bin already filled up with observations. Skipping...')
if len(obsStandars[obsStandars >= 0]) < nstars:
self.log.warning('Could not find %i suitable standard stars in catalog. Only %i where found.'%(nstars,len(obsStandars[obsStandars >= 0])))
#
# Unmarking potential targets as scheduled
#
for id in obsStandars[obsStandars >= 0]:
target = session.query(Targets).filter(Targets.id == id)
for t in target:
t.scheduled = False
session.commit()
tbin+=1
#
# Preparing a grid of altitudes for each target for each observing window
#
amGrid = np.zeros(len(obsStandars)*len(obsStandars)).reshape(len(obsStandars),len(obsStandars))
for i in np.arange(len(obsStandars))[obsStandars >= 0]:
target = session.query(Targets).filter(Targets.id == obsStandars[i])[0]
for j in range(len(obsStandars)):
lst = _skysub.lst(self.obsTimeBins[j],self.sitelong)
amGrid[i][j] = _skysub.true_airmass(_skysub.secant_z(_skysub.altit(target.targetDec,lst - target.targetRa,self.sitelat)[0]))
if amGrid[i][j] < 0:
amGrid [i][j] = 99.
#
# Build a grid mask that specifies the position in time each target should be observed. This means that, when
# selecting a single target we ocuppy more than one, non consecutive, position in the night. This grid shows where are these
# positions.
#
obsMask = np.zeros(len(obsStandars)*len(obsStandars),dtype=np.bool).reshape(len(obsStandars),len(obsStandars))
for i in np.arange(len(obsStandars))[obsStandars >= 0]:
amObs = np.linspace(amGrid[i].min(),self.stdMaxAirmass,nairmass) # requested aimasses
dam = np.mean(np.abs(amGrid[i][amGrid[i]<self.stdMaxAirmass][1:] - amGrid[i][amGrid[i]<self.stdMaxAirmass][:-1])) # how much airmass changes in average
for j,am in enumerate(amObs):
# Mark positions where target is at specified airmass
if j == 0:
obsMask[i] = np.bitwise_or(obsMask[i],amGrid[i] == am)
else:
obsMask[i] = np.bitwise_or(obsMask[i],np.bitwise_and(amGrid[i]>am-dam,amGrid[i]<am+dam))
#print amGrid[i][np.where(obsMask[i])]
#
# Now it is time to actually select the targets. It will start with the first target and then try the others
# until it find enough standard stars, as specified by the user.
#
# Para cada bin em tempo, varro o bin em massa de ar por coisas observaveis. Se acho um, vejo se posso agendar
# os outros bins. Se sim, marco o alvo para observacao, se nao, passo para o proximo. Repito ate completar a
# lista de alvos
#
obsMaskTimeGrid = np.zeros(len(obsStandars),dtype=np.bool)
nrequests = 0
reqId = np.zeros(nstars,dtype=np.int)-1
for tbin,time in enumerate(self.obsTimeBins[:-1]):
# Evaluates if time slots are all available. If yes, mark orbservation and ocuppy slots.
if ( (not obsMaskTimeGrid[obsMask[tbin]].any()) and (len(amGrid[tbin][obsMask[tbin]])>=nairmass) ):
obsMaskTimeGrid = np.bitwise_or(obsMaskTimeGrid,obsMask[tbin])
reqId[nrequests] = tbin
nrequests += 1
if nrequests >= nstars:
break
# Finally, requesting observations
for id in reqId[reqId >= 0]:
target = session.query(Targets).filter(Targets.id == obsStandars[id])[0]
secz = amGrid[id][obsMask[id]]
seczreq = np.zeros(nairmass,dtype=np.bool)
amObs = np.linspace(amGrid[id].min(),self.stdMaxAirmass,nairmass) # requested aimasses
for i,obstime in enumerate(self.obsTimeBins[obsMask[id]]):
sindex = np.abs(amObs-secz[i]).argmin()
if not seczreq[sindex]:
self.log.info('Requesting observations of %s @airmass=%4.2f @mjd=%.3f...'%(target.name,secz[i],obstime-2400000.5))
seczreq[sindex] = True
target.scheduled = True
session.commit()
self.addObservation(target,obstime)
self.obsTimeMask[obsMask[id]] = 1.0
#print self.obsTimeBins[obsMask[id]]
#print
#print i
return 0 #targets
