def worldAt(self, *pixel):
if not self._findWCS():
return Position.fromRaDec(0, 0)
world = self._valueAt(self._wcs.wcs_pix2world, *pixel)
return Position.fromRaDec(Coord.fromD(world[0]), Coord.fromD(world[1]))
def worldAt(self, *pixel):
if not self._findWCS():
return Position.fromRaDec(0, 0)
world = self._valueAt(self._wcs.wcs_pix2world, *pixel)
return Position.fromRaDec(Coord.fromD(world[0]), Coord.fromD(world[1]))
def test_distances(self):
p1 = Position.fromRaDec("10:00:00", "0:0:0")
p2 = Position.fromRaDec("12:00:00", "0:0:0")
d = p1.angsep(p2)
assert p1.within(p2, Coord.fromD(29.99)) == False
assert p1.within(p2, Coord.fromD(30.01)) == True
def test_distances(self):
p1 = Position.fromRaDec("10:00:00", "0:0:0")
p2 = Position.fromRaDec("12:00:00", "0:0:0")
d = p1.angsep(p2)
assert p1.within(p2, Coord.fromD(29.99)) == False
assert p1.within(p2, Coord.fromD(30.01)) == True
def park(self):
if self.isParked():
return True
# 1. slew to park position FIXME: allow different park
# positions and conversions from ra/dec -> az/alt
site = self.getManager().getProxy("/Site/0")
self.slewToRaDec(
Position.fromRaDec(str(self.getLocalSiderealTime()),
site["latitude"]))
# 2. stop tracking
self.stopTracking()
# 3. power off
#self.powerOff ()
self._parked = True
self.parkComplete()
return True
def slew(self):
slewFunction = None
target = None
currentPage = self.module.view.slewOptions.get_current_page()
if currentPage == 0:
raHour = self.module.view.raHourSpin.get_value()
raMinute = self.module.view.raMinuteSpin.get_value()
raSec = self.module.view.raSecSpin.get_value()
decDegree = self.module.view.decDegreeSpin.get_value()
decMinute = self.module.view.decMinuteSpin.get_value()
decSec = self.module.view.decSecSpin.get_value()
ra = "%2d:%2d:%2d" %(raHour, raMinute, raSec)
dec = "%2d:%2d:%2d" %(decDegree, decMinute, decSec)
epochStr = str(self.module.view.epochCombo.child.get_text()).lower()
if epochStr == "j2000":
epoch = Epoch.J2000
elif epochStr == "b1950":
epoch = Epoch.B1950
elif epochStr == "now":
epoch = Epoch.Now
else:
# FIXME
epoch = epochStr
target = Position.fromRaDec(ra, dec, epoch=epoch)
slewFunction = self.telescope.slewToRaDec
elif currentPage == 1:
altDegree = self.module.view.altDegreeSpin.get_value()
altMinute = self.module.view.altMinuteSpin.get_value()
altSec = self.module.view.altSecSpin.get_value()
azDegree = self.module.view.azDegreeSpin.get_value()
azMinute = self.module.view.azMinuteSpin.get_value()
azSec = self.module.view.azSecSpin.get_value()
alt = "%2d:%2d:%2d" %(altDegree, altMinute, altSec)
az = "%2d:%2d:%2d" %(azDegree, azMinute, azSec)
target = Position.fromAltAz(alt, az)
slewFunction = self.telescope.slewToAltAz
elif currentPage == 2:
target = str(self.module.view.objectNameCombo.child.get_text())
slewFunction = self.telescope.slewToObject
self.module.view.slewBeginUi()
try:
slewFunction(target)
except ObjectNotFoundException, e:
self.module.view.showError("Object %s was not found on our catalogs." % target)
def test_slew_abort(self):
site = self.manager.getProxy("/Site/0")
# go to know position
self.tel.slewToRaDec(Position.fromRaDec(site.LST(), site["latitude"]))
last = self.tel.getPositionRaDec()
# clear event checkings
FiredEvents = {}
# drift it
dest = Position.fromRaDec(last.ra + Coord.fromH(1),
last.dec + Coord.fromD(10))
real_dest = None
@callback(self.manager)
def slewBeginClbk(target):
global real_dest
real_dest = target
@callback(self.manager)
def slewCompleteClbk(position, status):
assert last.ra < position.ra < real_dest.ra
assert last.dec < position.dec < real_dest.dec
self.tel.slewBegin += slewBeginClbk
self.tel.slewComplete += slewCompleteClbk
# async slew
def slew():
tel = self.manager.getProxy(self.TELESCOPE)
tel.slewToRaDec(dest)
pool = ThreadPool()
pool.queueTask(slew)
# wait thread to be scheduled
time.sleep(2)
# abort and test
self.tel.abortSlew()
pool.joinAll()
# event checkings
self.assertEvents(TelescopeStatus.ABORTED)
def test_precession(self):
sirius_j2000 = Position.fromRaDec("06 45 08.9173", "-16 42 58.017")
sirius_now = sirius_j2000.precess()
print
print sirius_j2000
print sirius_now
def test_slew_abort (self):
site = self.manager.getProxy("/Site/0")
# go to know position
self.tel.slewToRaDec(Position.fromRaDec(site.LST(), site["latitude"]))
last = self.tel.getPositionRaDec()
# clear event checkings
FiredEvents = {}
# drift it
dest = Position.fromRaDec(last.ra+Coord.fromH(1), last.dec+Coord.fromD(10))
real_dest = None
@callback(self.manager)
def slewBeginClbk(target):
global real_dest
real_dest = target
@callback(self.manager)
def slewCompleteClbk(position, status):
assert last.ra < position.ra < real_dest.ra
assert last.dec < position.dec < real_dest.dec
self.tel.slewBegin += slewBeginClbk
self.tel.slewComplete += slewCompleteClbk
# async slew
def slew():
tel = self.manager.getProxy(self.TELESCOPE)
tel.slewToRaDec(dest)
pool = ThreadPool()
pool.queueTask(slew)
# wait thread to be scheduled
time.sleep(2)
# abort and test
self.tel.abortSlew()
pool.joinAll()
# event checkings
self.assertEvents(TelescopeStatus.ABORTED)
def test_changeEpoch(self):
sirius_j2000 = Position.fromRaDec("06 45 08.9173", "-16 42 58.017")
sirius_now = sirius_j2000.toEpoch(epoch=Epoch.NOW)
print()
print(sirius_j2000)
print(sirius_now)
def slewToRaDec(self, position):
# FIXME: validate limits?
if not isinstance(position, Position):
position = Position.fromRaDec(*position)
drv = self.getDriver()
drv.slewToRaDec(position)
def test_changeEpoch(self):
sirius_j2000 = Position.fromRaDec("06 45 08.9173", "-16 42 58.017")
sirius_now = sirius_j2000.toEpoch(epoch=Epoch.NOW)
print
print sirius_j2000
print sirius_now
def getTargetRaDec(self):
drv = self.getDriver()
ret = drv.getTargetRaDec()
if not isinstance(ret, Position):
ret = Position.fromRaDec(*ret)
return ret
def checkPointing(self):
"""
This method *chooses* a field to verify the telescope pointing.
Then it does the pointing and verifies it.
If unsuccesfull e-mail the operator for help
isto em portugues eh chamado calagem
Choice is based on some catalog (Landolt here)
We choose the field closest to zenith
"""
# find where the zenith is
site = self.getManager().getProxy("/Site/0")
lst = site.LST()
lat = site["latitude"]
coords = Position.fromRaDec(lst, lat)
self.log.info(
"Check pointing - Zenith coordinates: %f %f" % (lst, lat))
tel = self.getTel()
# use the Vizier catalogs to see what Landolt field is closest to
# zenith
self.log.debug("Calling landolt")
fld = Landolt()
fld.useTarget(coords, radius=45)
obj = fld.find(limit=self["max_fields"])
print "Objects returned from Landolt", obj
# get ra, dec to call pointVerify
ra = obj[self.currentField]["RA"]
dec = obj[self.currentField]["DEC"]
name = obj[self.currentField]["ID"]
print "Current object ", ra, dec, name
self.log.info("Chose %s %f %f" % (name, ra, dec))
tel.slewToRaDec(Position.fromRaDec(ra, dec))
try:
self.pointVerify()
except Exception, e:
printException(e)
raise CantSetScopeException(
"Can't set scope on field %s %f %f we are in trouble, call for help" %
(name, ra, dec))
def checkPointing(self):
"""
This method *chooses* a field to verify the telescope pointing.
Then it does the pointing and verifies it.
If unsuccesfull e-mail the operator for help
isto em portugues eh chamado calagem
Choice is based on some catalog (Landolt here)
We choose the field closest to zenith
"""
# find where the zenith is
site = self.getManager().getProxy("/Site/0")
lst = site.LST()
lat = site["latitude"]
coords = Position.fromRaDec(lst, lat)
self.log.info("Check pointing - Zenith coordinates: %f %f" %
(lst, lat))
tel = self.getTel()
# use the Vizier catalogs to see what Landolt field is closest to zenith
self.log.debug("Calling landolt")
fld = Landolt()
fld.useTarget(coords, radius=45)
obj = fld.find(limit=self["max_fields"])
print "Objects returned from Landolt", obj
# get ra, dec to call pointVerify
ra = obj[self.currentField]["RA"]
dec = obj[self.currentField]["DEC"]
name = obj[self.currentField]["ID"]
print "Current object ", ra, dec, name
self.log.info("Chose %s %f %f" % (name, ra, dec))
tel.slewToRaDec(Position.fromRaDec(ra, dec))
try:
self.pointVerify()
except Exception, e:
printException(e)
raise CantSetScopeException(
"Can't set scope on field %s %f %f we are in trouble, call for help"
% (name, ra, dec))
def __init__(self, buffer):
# discard time
buffer.recv(8)
self.ra = struct.unpack("<1I", buffer.recv(4))[0]
self.ra *= (math.pi / 0x80000000)
self.ra = Coord.fromR(self.ra).toHMS()
self.dec = struct.unpack("<1i", buffer.recv(4))[0]
self.dec *= (math.pi / 0x80000000)
self.dec = Coord.fromR(self.dec).toDMS()
self.position = Position.fromRaDec(self.ra, self.dec)
def __main__(self):
tel = self.getManager().getProxy("/Telescope/0")
cam = self.getManager().getProxy("/Camera/0")
dome = self.getManager().getProxy("/Dome/0")
autofocus = self.getManager().getProxy("/Autofocus/0")
verify = self.getManager().getProxy("/PointVerify/0")
landolt = Landolt()
landolt.useTarget(Position.fromRaDec("00:38:00", "-22:00:00"),
radius=45)
landolt.constrainColumns({"Vmag": "<11"})
landolts = landolt.find(limit=3)
for landolt in landolts:
pos = Position.fromRaDec(landolt["RA"], landolt["DEC"])
self.log.info("Slewing to %s" % pos)
tel.slewToRaDec(pos)
while (tel.isSlewing() or not dome.isSyncWithTel()):
self.log.info("Waiting dome...")
self.log.info("Doing autofocus on %s" % pos)
fit = autofocus.focus(target=Target.CURRENT,
mode=Mode.FIT,
exptime=20,
start=0,
end=7000,
step=1000)
self.log.info("Verifyng pointing...")
verify.pointVerify()
cam.expose(exp_time=120,
shutter="OPEN",
frames=1,
filename="extincao-%s" %
landolt["ID"].replace(" ", "_"))
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)
def test_find(self):
landolt = Landolt()
landolt.useTarget(Position.fromRaDec("14:00:00", "-22:00:00"),
radius=45)
landolt.constrainColumns({"Vmag": "<10"})
data = landolt.find(limit=5)
for obj in data:
for k, v in obj.items():
print k, v
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)
def test_slew_to_ra_dec (self):
m = self.m
print
self.printCoord (header=True)
ra = m.getRa()
m.slewToRaDec (Position.fromRaDec(ra, "-70:00:00"))
#m.slewToRaDec (Position.fromRaDec("13h25m38.903s", "-11:12:24.928"))
self.printCoord()
def test_find (self):
x = VizQuery()
x.useCat("II/183A/")
x.useColumns("*POS_EQ_RA_MAIN,*POS_EQ_DEC_MAIN,*ID_MAIN,Vmag,_r",
sortBy="*POS_EQ_RA_MAIN")
x.useTarget(Position.fromRaDec("14:00:00","-22:00:00"),radius=45)
data = x.find(limit=5)
for obj in data:
for k,v in obj.items():
print k, v
print
def test_find(self):
x = VizQuery()
x.useCat("II/183A/")
x.useColumns("*POS_EQ_RA_MAIN,*POS_EQ_DEC_MAIN,*ID_MAIN,Vmag,_r",
sortBy="*POS_EQ_RA_MAIN")
x.useTarget(Position.fromRaDec("14:00:00", "-22:00:00"), radius=45)
data = x.find(limit=5)
for obj in data:
for k, v in list(obj.items()):
print(k, v)
print()
def test_find (self):
landolt = Landolt()
landolt.useTarget(Position.fromRaDec("14:00:00","-22:00:00"),radius=45)
landolt.constrainColumns({"Vmag":"<10"})
data = landolt.find(limit=5)
for obj in data:
for k,v in obj.items():
assert k
assert v
print k, v
def _parseSesame (xml):
try:
sesame = ET.fromstring(xml.replace("&", "&"))
target = sesame.findall("Target")
if target:
for resolver in target[0].findall("Resolver"):
jpos = resolver.find("jpos")
if jpos is None:
continue
return Position.fromRaDec(*jpos.text.split())
except ExpatError, e:
return False
def _parseSesame(xml):
try:
sesame = ET.fromstring(xml.replace("&", "&"))
target = sesame.findall("Target")
if target:
for resolver in target[0].findall("Resolver"):
jpos = resolver.find("jpos")
if jpos is None:
continue
return Position.fromRaDec(*jpos.text.split())
except ExpatError, e:
return False
def test_park(self):
# FIXME: make a real test.
raise SkipTest()
def printPosition():
print self.tel.getPositionRaDec(), self.tel.getPositionAltAz()
sys.stdout.flush()
print
ra = self.tel.getRa()
dec = self.tel.getDec()
print "current position:", self.tel.getPositionRaDec()
print "moving to:", (ra - "01 00 00"), (dec - "01 00 00")
self.tel.slewToRaDec(
Position.fromRaDec(ra - Coord.fromH(1), dec - Coord.fromD(1)))
for i in range(10):
printPosition()
time.sleep(0.5)
print "parking..."
sys.stdout.flush()
self.tel.park()
t0 = time.time()
wait = 30
for i in range(10):
printPosition()
time.sleep(0.5)
while time.time() < t0 + wait:
print "\rwaiting ... ",
sys.stdout.flush()
time.sleep(1)
print "unparking..."
sys.stdout.flush()
self.tel.unpark()
for i in range(10):
printPosition()
time.sleep(0.5)
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)
# Change position epoch to J2000.
# Most of the Telescopes must have this precession calculation, otherwise pointing to positions of epochs
# different of J2000 will point the telescope to a wrong position.
# This should be done after self.slewBegin()
if position.epoch != Epoch.J2000:
position = position.toEpoch(Epoch.J2000)
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.startTracking()
self.slewComplete(self.getPositionRaDec(), status)
def __str__(self):
raDec = Position.fromRaDec(self.targetRa, self.targetDec, 'J2000')
if self.observed:
msg = "#[id: %5d] [name: %15s %s (ah: %.2f)] [type: %s] #LastObverved@: %s"
return msg % (self.id, self.name, raDec, self.targetAH, self.type,
self.lastObservation)
else:
msg = "#[id: %5d] [name: %15s %s (ah: %.2f)] [type: %s] #NeverObserved"
return msg % (
self.id,
self.name,
raDec,
self.targetAH,
self.type,
)
def test_park (self):
# FIXME: make a real test.
raise SkipTest()
def printPosition():
print self.tel.getPositionRaDec(), self.tel.getPositionAltAz()
sys.stdout.flush()
print
ra = self.tel.getRa()
dec = self.tel.getDec()
print "current position:", self.tel.getPositionRaDec()
print "moving to:", (ra-"01 00 00"), (dec-"01 00 00")
self.tel.slewToRaDec(Position.fromRaDec(ra-Coord.fromH(1), dec-Coord.fromD(1)))
for i in range(10):
printPosition()
time.sleep(0.5)
print "parking..."
sys.stdout.flush()
self.tel.park()
t0 = time.time()
wait = 30
for i in range(10):
printPosition()
time.sleep(0.5)
while time.time() < t0+wait:
print "\rwaiting ... ",
sys.stdout.flush()
time.sleep(1)
print "unparking..."
sys.stdout.flush()
self.tel.unpark()
for i in range(10):
printPosition()
time.sleep(0.5)
def __main__(self):
tel = self._getTel()
tel.slewComplete += self.getProxy()._updateSlewPosition
tel.abortComplete += self.getProxy()._updateSlewPosition
self._updateSlewPosition(tel.getPositionRaDec())
# From man(7) fifo: The FIFO must be opened on both ends
#(reading and writing) before data can be passed. Normally,
#opening the FIFO blocks until the other end is opened also
# force non-blocking open
fd = os.open(self._in_fifo, os.O_RDONLY | os.O_NONBLOCK)
in_fifo = os.fdopen(fd, "r")
while not self._loop_abort.isSet():
ret = select([in_fifo], [], [], 0)
# timeout
if not any(ret):
time.sleep(1)
continue
try:
edb = in_fifo.readline()
# writer not connected (XEphem closed)
if not edb:
time.sleep(1)
continue
edb = edb.split(",")
ra = edb[2].split("|")[0].strip()
dec = edb[3].split("|")[0].strip()
target = Position.fromRaDec(ra, dec)
self.log.info("XEphem FIFO changed: slewing to %s" % target)
self._getTel().slewToRaDec(target)
except (ValueError, IndexError):
self.log.exception("Cannot convert XEphem EDB to Position.")
continue
except:
self.log.exception("Something wrong...")
def __main__(self):
tel = self._getTel()
tel.slewComplete += self.getProxy()._updateSlewPosition
self._updateSlewPosition(tel.getPositionRaDec(), None)
# From man(7) fifo: The FIFO must be opened on both ends
#(reading and writing) before data can be passed. Normally,
# opening the FIFO blocks until the other end is opened also
# force non-blocking open
fd = os.open(self._in_fifo, os.O_RDONLY | os.O_NONBLOCK)
in_fifo = os.fdopen(fd, "r")
while not self._loop_abort.isSet():
ret = select([in_fifo], [], [], 0)
# timeout
if not any(ret):
time.sleep(1)
continue
try:
edb = in_fifo.readline()
# writer not connected (XEphem closed)
if not edb:
time.sleep(1)
continue
edb = edb.split(",")
ra = edb[2].split("|")[0].strip()
dec = edb[3].split("|")[0].strip()
target = Position.fromRaDec(ra, dec)
self.log.info("XEphem FIFO changed: slewing to %s" % target)
self._getTel().slewToRaDec(target)
except (ValueError, IndexError):
self.log.exception("Cannot convert XEphem EDB to Position.")
continue
except:
self.log.exception("Something wrong...")
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)
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)
def test_sync (self):
# get current position, drift the scope, and sync on the first
# position (like done when aligning the telescope).
real = self.tel.getPositionRaDec()
@callback(self.manager)
def syncCompleteClbk(position):
assert position.ra == real.ra
assert position.dec == real.dec
self.tel.syncComplete += syncCompleteClbk
# drift to "real" object coordinate
drift = Position.fromRaDec(real.ra+Coord.fromH(1), real.dec+Coord.fromD(1))
self.tel.slewToRaDec(drift)
self.tel.syncRaDec(real)
time.sleep(2)
def test_sync (self):
# get current position, drift the scope, and sync on the first
# position (like done when aligning the telescope).
real = self.tel.getPositionRaDec()
@callback(self.manager)
def syncCompleteClbk(position):
assert position.ra == real.ra
assert position.dec == real.dec
self.tel.syncComplete += syncCompleteClbk
# drift to "real" object coordinate
drift = Position.fromRaDec(real.ra+Coord.fromH(1), real.dec+Coord.fromD(1))
self.tel.slewToRaDec(drift)
self.tel.syncRaDec(real)
time.sleep(2)
def test_stress_dome_track (self):
dome = self.manager.getProxy(self.DOME)
tel = self.manager.getProxy(self.TELESCOPE)
dome.track()
for i in range(10):
FiredEvents = {}
self.setupEvents()
ra = "%d %d 00" % (random.randint(7,15), random.randint(0,59))
dec = "%d %d 00" % (random.randint(-90,0), random.randint(0,59))
tel.slewToRaDec(Position.fromRaDec(ra, dec))
dome.syncWithTel()
assertDomeAz(dome.getAz(), tel.getAz(), dome["az_resolution"])
self.assertEvents(sync=True)
time.sleep(random.randint(0,10))
def telegram_set_target(self, bot, update, args, job_queue, chat_data):
if len(args) != 2:
update.message.reply_text(
"Usage: /set HH:MM:SS.S DD:MM:SS.S or /set ra dec (J2000)")
else:
self.last_update = datetime.datetime.now()
ra = Coord.fromHMS(args[0]) if ":" in args[0] else Coord.fromD(
float(args[0]))
dec = Coord.fromDMS(args[1]) if ":" in args[1] else Coord.fromD(
float(args[1]))
self.target = Position.fromRaDec(ra, dec)
site = self.getSite()
lst = site.LST_inRads()
alt = float(site.raDecToAltAz(self.target, lst).alt)
# TODO: reject if alt< telescope_min_alt!
moonPos = site.moonpos()
moonRaDec = site.altAzToRaDec(moonPos, lst)
moonDist = self.target.angsep(moonRaDec)
update.message.reply_text(
'Hello {} arg is {} {}. Object alt = {}, Moon dist = {}'.
format(update.message.from_user.first_name, args[0], args[1],
alt, moonDist))
def pointVerify (self):
""" Checks telescope pointing
Checks the pointing.
If abs ( telescope coordinates - image coordinates ) > tolerance
move the scope
take a new image
test again
do this while ntrials < max_trials
Returns True if centering was succesful
False if not
"""
# take an image and read its coordinates off the header
image = None
try:
image = self._takeImage()
print "image name %s", image.filename()
except:
self.log.error( "Can't take image" )
raise
ra_img_center = image["CRVAL1"] # expects to see this in image
dec_img_center= image["CRVAL2"]
currentImageCenter = Position.fromRaDec(Coord.fromD(ra_img_center),
Coord.fromD(dec_img_center))
tel = self.getTel()
# analyze the previous image using
# AstrometryNet defined in util
try:
wcs_name = AstrometryNet.solveField(image.filename(),findstarmethod="sex")
except NoSolutionAstrometryNetException, e:
raise e
def pointVerify(self):
""" Checks telescope pointing
Checks the pointing.
If abs ( telescope coordinates - image coordinates ) > tolerance
move the scope
take a new image
test again
do this while ntrials < max_trials
Returns True if centering was succesful
False if not
"""
# take an image and read its coordinates off the header
image = None
try:
image = self._takeImage()
print "image name %s", image.filename()
except:
self.log.error("Can't take image")
raise
ra_img_center = image["CRVAL1"] # expects to see this in image
dec_img_center = image["CRVAL2"]
currentImageCenter = Position.fromRaDec(Coord.fromD(ra_img_center),
Coord.fromD(dec_img_center))
tel = self.getTel()
# analyze the previous image using
# AstrometryNet defined in util
try:
wcs_name = AstrometryNet.solveField(image.filename(),
findstarmethod="sex")
except NoSolutionAstrometryNetException, e:
raise e
def trigger_observation(self,
ra,
dec,
trigger_time=datetime.datetime.utcnow()):
"""
Acquire observatory control, point and start exposing
:return:
"""
# Clear previous abort state
self.abort.clear()
# Acquire telescope via supervisor action
self.acquire_telescope()
telescope = self.getTelescope()
# Point
self.log.debug("Slewing to ra, dec %.2f %.2f" % (ra, dec))
telescope.slewToRaDec(
Position.fromRaDec(Coord.fromD(ra), Coord.fromD(dec)))
# Start expose sequence
# TODO: register a method change_filter to the camera readout
camera = self.getCamera()
filterwheel = self.getFilterWheel()
with open(os.path.expanduser("~/.chimera/grb_sequence.json")) as fp:
sequence = json.load(fp)
for request in sequence:
self.log.debug("Exposing: %s" % str(request))
filterwheel.setFilter(request.pop('filter'))
camera.expose(request)
if self.abort.is_set():
self.release_telescope()
return False
self.release_telescope()
return True
def test_slew (self):
site = self.manager.getProxy("/Site/0")
dest = Position.fromRaDec(site.LST(), site["latitude"])
real_dest = None
@callback(self.manager)
def slewBeginClbk(target):
global real_dest
real_dest = target
@callback(self.manager)
def slewCompleteClbk(position, status):
assertEpsEqual(position.ra, real_dest.ra, 60)
assertEpsEqual(position.dec, real_dest.dec, 60)
self.tel.slewBegin += slewBeginClbk
self.tel.slewComplete += slewCompleteClbk
self.tel.slewToRaDec(dest)
# event checkings
self.assertEvents(TelescopeStatus.OK)
def park (self):
if self.isParked ():
return True
# 1. slew to park position FIXME: allow different park
# positions and conversions from ra/dec -> az/alt
site = self.getManager().getProxy("/Site/0")
self.slewToRaDec(Position.fromRaDec(str(self.getLocalSiderealTime()),
site["latitude"]))
# 2. stop tracking
self.stopTracking ()
# 3. power off
#self.powerOff ()
self._parked = True
self.parkComplete()
return True
def test_slew (self):
site = self.manager.getProxy("/Site/0")
dest = Position.fromRaDec(site.LST(), site["latitude"])
real_dest = None
@callback(self.manager)
def slewBeginClbk(target):
global real_dest
real_dest = target
@callback(self.manager)
def slewCompleteClbk(position, status):
assertEpsEqual(position.ra, real_dest.ra, 60)
assertEpsEqual(position.dec, real_dest.dec, 60)
self.tel.slewBegin += slewBeginClbk
self.tel.slewComplete += slewCompleteClbk
self.tel.slewToRaDec(dest)
# event checkings
self.assertEvents(TelescopeStatus.OK)
def getPositionRaDec(self):
self._telescope.GetRaDec()
return Position.fromRaDec(Coord.fromH(self._telescope.dRa), Coord.fromD(self._telescope.dDec))
def addObservation(self,target,obstime):
session = Session()
lineRe = re.compile('(?P<coord>(?P<ra>[\d:-]+)\s+(?P<dec>\+?[\d:-]+)\s+(?P<epoch>[\dnowNOWJjBb\.]+)\s+)?(?P<imagetype>[\w]+)'
'\s+(?P<objname>\'([^\\n\'\\\\]|\\\\.)*\'|"([^\\n"\\\\]|\\\\.)*"|([^ \\n"\\\\]|\\\\.)*)\s+(?P<exposures>[\w\d\s:\*\(\),]*)')
programs = []
entryFormat = '%(ra)s %(dec)s %(epoch)s %(obstype)s %(name)s %(exposures)s'
p = Position.fromRaDec(target.targetRa,target.targetDec)
ra = p.ra.HMS
dec = p.dec.DMS
filterExpt = self.sciExpTime
if target.type == self.stdFlag:
filterExpt = self.stdExpTime
exposures = '1*('
for i in range(self.nfilters):
exposures = exposures+'%s:%.0f, '%(self.filters[i],filterExpt[i])
exposures = exposures[:-2]
exposures += ')'
infos = { 'ra' : '%02.0f:%02.0f:%02.0f'%(ra[1],ra[2],ra[3]),
'dec': '%+03.0f:%02.0f:%02.0f'%(dec[0]*dec[1],dec[2],dec[3]),
'epoch' : 'J%.0f'%target.targetEpoch,
'obstype' : 'OBJECT',
'name' :target.name,
'exposures' : exposures
}
i = 0
line = entryFormat%infos
matchs = lineRe.search(line)
params = matchs.groupdict()
position = None
objname = None
if params.get("coord", None):
position = Position.fromRaDec(str(params['ra']), str(params['dec']), params['epoch'])
imagetype = params['imagetype'].upper()
objname = params['objname'].replace("\"", "")
multiplier, exps = params['exposures'].split("*")
try:
multiplier = int(multiplier)
except ValueError:
multiplier = 1
exps = exps.replace("(", "").replace(")", "").strip().split(",")
mjd = obstime - 2400000.5
for i in range(multiplier):
program = Program(tid = target.id ,name="%s-%03d" % (objname.replace(" ", ""), i),
slewAt=mjd,exposeAt=mjd+1./60./24.)
self.log.info("# program: %s" % program.name)
if imagetype == "OBJECT":
if position:
program.actions.append(Point(targetRaDec=position))
else:
program.actions.append(Point(targetName=objname))
if imagetype == "FLAT":
site = self._remoteManager.getProxy("/Site/0")
flatPosition = Position.fromAltAz(site['flat_alt'], site['flat_az'])
program.actions.append(Point(targetAltAz=flatPosition))
#if i == 0:
# program.actions.append(AutoFocus(start=1500, end=3000, step=250, filter="R", exptime=10))
# program.actions.append(PointVerify(here=True))
for exp in exps:
if exp.count(":") > 1:
filter, exptime, frames = exp.strip().split(":")
else:
filter, exptime = exp.strip().split(":")
frames = 1
if imagetype in ("OBJECT", "FLAT"):
shutter = "OPEN"
else:
shutter = "CLOSE"
if imagetype == "BIAS":
exptime = 0
if imagetype in ("BIAS", "DARK"):
filter = None
self.log.info("%s %s %s filter=%s exptime=%s frames=%s" % (imagetype, objname, str(position), filter, exptime, frames))
program.actions.append(Expose(shutter=shutter,
filename="%s-$DATE-$TIME" % objname.replace(" ", ""),
filter=filter,
frames=frames,
exptime=exptime,
imageType=imagetype,
objectName=objname))
self.log.info("")
programs.append(program)
session.add_all(programs)
session.commit()
def targets(self):
'''
After selecting targets, you can generate a list of potential targets to run the scheduler.
'''
session = Session()
fp1 = open(os.path.join(self.PATH,'Fixed.txt'),'w')
fp2 = open(os.path.join(self.PATH,'request.stg'),'w')
# Write header
fp1.write('''P|Designation | RA | dec |mag.
-|------------|hh mm ss.ss|sdd mm ss.s|nn.n
''')
config = { 'name' : '',
'user' : '',
'nimages' : 1,
'expt' : 0,
'filter' : '',
'time' : ''}
for obstype in [self.stdFlag,self.sciFlag]:
targets = session.query(Targets,Program).join((Program,Targets.id==Program.tid)).filter(Targets.type == obstype).order_by(Targets.name)
tobs = []
tname = ''
FlagFilterClear = True
for target,program in targets:
p = Position.fromRaDec(target.targetRa,target.targetDec)
ra = p.ra.HMS
dec = p.dec.DMS
#
# Write Fixed.txt
#
objname = '%12s'%(target.name).replace(' ','_')
objname = objname.replace(' ','_')
fp1.write('%1s %s %02.0f %02.0f %05.2f %+03.0f %02.0f %04.1f %04.1f\n'%( target.type,
objname,
ra[1],
ra[2],
ra[3],
dec[0]*dec[1],
dec[2],
dec[3],target.targetMag))
#
# Write stg file with observation requests
#
config['name'] = objname
config['user'] = self.stdUser
filterExpt = self.stdExpTime
if target.type == self.sciFlag:
config['user'] = self.sciUser
filterExpt = self.sciExpTime
config['time'] = ''
dt = np.max(filterExpt)*self.nfilters/60./60./24.
if target.type ==self.stdFlag:
FlagFilterClear = True
tname = target.name
tstart = datetimeFromJD(program.slewAt + 2400000.5)
tend = datetimeFromJD(program.slewAt+dt + 2400000.5)
config['time'] = 't>%s t<%s'%(tstart.strftime('%y%m%d-%H:%M'),tend.strftime('%y%m%d-%H:%M'))
for i in range(self.nfilters):
config['expt'] = filterExpt[i]
config['filter'] = self.filters[i]
tstart = datetimeFromJD(program.slewAt + 2400000.5)
tend = datetimeFromJD(program.slewAt+dt*1.1 + 2400000.5)
fp2.write('%(name)12s; %(user)s %(nimages)ii exp=%(expt).2f opt filter=%(filter)s %(time)s\n'%config)
fp1.close()
fp2.close()
return 0
def syncRaDec(self, position):
if not isinstance(position, Position):
position = Position.fromRaDec(*position)
self._ra = position.ra
self._dec = position.dec
def _setAltAzFromRaDec(self):
altAz = self._getSite().raDecToAltAz(
Position.fromRaDec(self._ra, self._dec))
self._alt = altAz.alt
self._az = altAz.az
def getPositionRaDec(self):
return Position.fromRaDec(self.getRa(), self.getDec(), epoch=self._epoch)
def getPositionRaDec(self):
self._telescope.GetRaDec()
return Position.fromRaDec(Coord.fromH(self._telescope.dRa),
Coord.fromD(self._telescope.dDec))
def test_park (self):
m = self.m
print
print "="*50
print "Park and unpark test"
print "="*50
print "Initial conditions (post power-on):"
self.test_print_info()
print
print "Starting the scope..."
self.test_set_info()
print
print "Scope location, date, time updated, new conditions:"
self.test_print_info()
print
print "Pooling telescope position:"
ra = m.getRa()
self.printCoord(header=True)
for i in range(10):
self.printCoord ()
time.sleep (1)
print
print "Slewing... to %s -70:00:00" % ra
m.slewToRaDec (Position.fromRaDec(ra, "-70:00:00"))
print
print "Parking the scope at %s (lst: %s)" % (time.strftime("%c"), m.getLocalSiderealTime())
m.park ()
print
print "Pooling telescope position:"
self.printCoord(header=True)
for i in range(10):
self.printCoord ()
time.sleep (1)
print
start = time.time ()
finish = start + (2*60) # wait 30 minutes
print "Waiting ",
while time.time() < finish:
update_scroll_spinner()
time.sleep (0.2)
print
print "Unparking the scope at %s (lst: %s)" % (time.strftime("%c"),
m.getLocalSiderealTime())
m.unpark ()
print
print "Pooling telescope position:"
for i in range(10):
self.printCoord ()
time.sleep (1)
print "="*50
def slew(self):
slewFunction = None
target = None
currentPage = self.module.view.slewOptions.get_current_page()
if currentPage == 0:
raHour = self.module.view.raHourSpin.get_value()
raMinute = self.module.view.raMinuteSpin.get_value()
raSec = self.module.view.raSecSpin.get_value()
decDegree = self.module.view.decDegreeSpin.get_value()
decMinute = self.module.view.decMinuteSpin.get_value()
decSec = self.module.view.decSecSpin.get_value()
ra = "%2d:%2d:%2d" % (raHour, raMinute, raSec)
dec = "%2d:%2d:%2d" % (decDegree, decMinute, decSec)
epochStr = str(
self.module.view.epochCombo.child.get_text()).lower()
if epochStr == "j2000":
epoch = Epoch.J2000
elif epochStr == "b1950":
epoch = Epoch.B1950
elif epochStr == "now":
epoch = Epoch.Now
else:
# FIXME
epoch = epochStr
target = Position.fromRaDec(ra, dec, epoch=epoch)
slewFunction = self.telescope.slewToRaDec
elif currentPage == 1:
altDegree = self.module.view.altDegreeSpin.get_value()
altMinute = self.module.view.altMinuteSpin.get_value()
altSec = self.module.view.altSecSpin.get_value()
azDegree = self.module.view.azDegreeSpin.get_value()
azMinute = self.module.view.azMinuteSpin.get_value()
azSec = self.module.view.azSecSpin.get_value()
alt = "%2d:%2d:%2d" % (altDegree, altMinute, altSec)
az = "%2d:%2d:%2d" % (azDegree, azMinute, azSec)
target = Position.fromAltAz(alt, az)
slewFunction = self.telescope.slewToAltAz
elif currentPage == 2:
target = str(self.module.view.objectNameCombo.child.get_text())
slewFunction = self.telescope.slewToObject
self.module.view.slewBeginUi()
try:
slewFunction(target)
except ObjectNotFoundException, e:
self.module.view.showError(
"Object %s was not found on our catalogs." % target)
class PointVerify(ChimeraObject, IPointVerify):
"""
Verifies telescope pointing.
There are two ways of doing this:
- verify the field the scope has been pointed to
- choose a field (from a list of certified fields) and try verification
"""
# normal constructor
# initialize the relevant variables
def __init__(self):
ChimeraObject.__init__(self)
self.ntrials = 0 # number times we try to center on a field
self.nfields = 0 # number of fields we try to center on
self.checkedpointing = False # True = Standard field is verified
self.currentField = 0 # counts fields tried to verify
#def __start__ (self):
#self.pointVerify()
#self.checkPointing()
#return True
def getTel(self):
return self.getManager().getProxy(self["telescope"])
def getCam(self):
return self.getManager().getProxy(self["camera"])
def getFilter(self):
return self.getManager().getProxy(self["filterwheel"])
def _takeImage(self):
cam = self.getCam()
frames = cam.expose(exptime=self["exptime"],
frames=1,
shutter=Shutter.OPEN,
filename="pointverify-$DATE")
if frames:
return frames[0]
else:
raise Exception("Could not take an image")
def pointVerify(self):
""" Checks telescope pointing
Checks the pointing.
If abs ( telescope coordinates - image coordinates ) > tolerance
move the scope
take a new image
test again
do this while ntrials < max_trials
Returns True if centering was succesful
False if not
"""
# take an image and read its coordinates off the header
image = None
try:
image = self._takeImage()
print "image name %s", image.filename()
except:
self.log.error("Can't take image")
raise
ra_img_center = image["CRVAL1"] # expects to see this in image
dec_img_center = image["CRVAL2"]
currentImageCenter = Position.fromRaDec(Coord.fromD(ra_img_center),
Coord.fromD(dec_img_center))
tel = self.getTel()
# analyze the previous image using
# AstrometryNet defined in util
try:
wcs_name = AstrometryNet.solveField(image.filename(),
findstarmethod="sex")
except NoSolutionAstrometryNetException, e:
raise e
# why can't I select this exception?
#
# there was no solution to this field.
# send the telescope back to checkPointing
# if that fails, clouds or telescope problem
# an exception will be raised there
#self.log.error("No WCS solution")
#if not self.checkedpointing:
# self.nfields += 1
# self.currentField += 1
# if self.nfields <= self["max_fields"] and self.checkPointing() == True:
# self.checkedpointing = True
# tel.slewToRaDec(currentImageCenter)
# try:
# self.pointVerify()
# return True
# except CanSetScopeButNotThisField:
# raise
#
# else:
# self.checkedpointing = False
# self.currentField = 0
# raise Exception("max fields")
#
#else:
# self.checkedpointing = False
# raise CanSetScopeButNotThisField("Able to set scope, but unable to verify this field %s" %(currentImageCenter))
wcs = Image.fromFile(wcs_name)
ra_wcs_center = wcs["CRVAL1"] + (wcs["NAXIS1"] / 2.0 -
wcs["CRPIX1"]) * wcs["CD1_1"]
dec_wcs_center = wcs["CRVAL2"] + (wcs["NAXIS2"] / 2.0 -
wcs["CRPIX2"]) * wcs["CD2_2"]
currentWCS = Position.fromRaDec(Coord.fromD(ra_wcs_center),
Coord.fromD(dec_wcs_center))
# save the position of first trial:
if (self.ntrials == 0):
initialPosition = Position.fromRaDec(Coord.fromD(ra_img_center),
Coord.fromD(dec_img_center))
initialWCS = Position.fromRaDec(currentWCS.ra, currentWCS.dec)
# write down the two positions for later use in mount models
if (self.ntrials == 0):
site = self.getManager().getProxy("/Site/0")
logstr = "Pointing Info for Mount Model: %s %s %s %s %s" % (
site.LST(), site.MJD(), image["DATE-OBS"], initialPosition,
currentWCS)
self.log.info(logstr)
delta_ra = ra_img_center - ra_wcs_center
delta_dec = dec_img_center - dec_wcs_center
self.log.debug("delta_ra: %s delta_dec: %s" % (delta_ra, delta_dec))
self.log.debug("ra_img_center: %s ra_wcs_center: %s" %
(ra_img_center, ra_wcs_center))
self.log.debug("dec_img_center: %s dec_wcs_center: %s" %
(dec_img_center, dec_wcs_center))
# *** need to do real logging here
logstr = "%s %f %f %f %f %f %f" % (image["DATE-OBS"], ra_img_center,
dec_img_center, ra_wcs_center,
dec_wcs_center, delta_ra, delta_dec)
self.log.debug(logstr)
if (fabs(delta_ra) > self["tolra"]) or (fabs(delta_dec) >
self["toldec"]):
print "Telescope not there yet."
print "Trying again"
self.ntrials += 1
if (self.ntrials > self["max_trials"]):
self.ntrials = 0
raise CantPointScopeException(
"Scope does not point with a precision of %f (RA) or %f (DEC) after %d trials\n"
% (self["tolra"], self["toldec"], self["max_trials"]))
time.sleep(5)
tel.moveOffset(Coord.fromD(delta_ra).AS,
Coord.fromD(delta_dec).AS,
rate=SlewRate.CENTER)
self.pointVerify()
else:
# if we got here, we were succesfull, reset trials counter
self.ntrials = 0
self.currentField = 0
# and save final position
# write down the two positions for later use in mount models
logstr = "Pointing: final solution %s %s %s" % (
image["DATE-OBS"], currentImageCenter, currentWCS)
#self.log.debug("Synchronizing telescope on %s" % currentWCS)
#tel.syncRaDec(currentWCS)
# *** should we sync the scope ???
# maybe there should be an option of syncing or not
# the first pointing in the night should sync I believe
# subsequent pointings should not.
# another idea is to sync if the delta_coords at first trial were larger than some value
self.log.info(logstr)
return (True)
def getPositionRaDec(self):
self._telescope.GetRaDec()
return Position.fromRaDec(Coord.fromH(self._telescope.dRa),
Coord.fromD(self._telescope.dDec),
epoch=Epoch.NOW).toEpoch(Epoch.J2000)
def _setAltAzFromRaDec(self):
altAz = self._getSite().raDecToAltAz(
Position.fromRaDec(self._ra, self._dec))
self._alt = altAz.alt
self._az = altAz.az
def test_ra_dec (self):
p = Position.fromRaDec("10:00:00", "20 00 00")
assert p.dd() == (150, 20)
assert_raises(ValueError, Position.fromRaDec, "xyz", "abc")
def getTargetRaDec(self):
return Position.fromRaDec(self.getRa(), self.getDec())
def checkConditions(self,
program,
time,
program_length=0.,
external_checker=None):
'''
Check if a program can be executed given all restrictions imposed by airmass, moon distance,
seeing, cloud cover, etc...
[comment] There must be a good way of letting the user rewrite this easily. I can only
think about a decorator but I am not sure how to implement it.
:param program:
:return: True (Program can be executed) | False (Program cannot be executed)
'''
site = self.getSite()
# 1) check airmass
session = RSession()
# program = session.merge(prg)
target = session.merge(program[3])
# obsblock = session.merge(program[2])
blockpar = session.merge(program[1])
raDec = Position.fromRaDec(target.targetRa, target.targetDec)
dateTime = datetimeFromJD(time + 2400000.5)
lst = site.LST_inRads(dateTime) # in radians
alt = float(site.raDecToAltAz(raDec, lst).alt)
airmass = 1. / np.cos(np.pi / 2. - alt * np.pi / 180.)
if blockpar.minairmass < airmass < blockpar.maxairmass:
self._debuglog.debug('\tairmass:%.3f' % airmass)
pass
else:
self._debuglog.warning(
'Target %s out of airmass range @ %.3f... (%f < %f < %f)' %
(target, time, blockpar.minairmass, airmass,
blockpar.maxairmass))
return False
if program_length > 0.:
observation_end = datetimeFromJD((time + program_length / 86.4e3) +
2400000.5).replace(tzinfo=None)
# lst = site.LST_inRads(dateTime) # in radians
night_end = site.sunrise_twilight_begin(dateTime).replace(
tzinfo=None)
if observation_end > night_end:
self._debuglog.warning(
'Block finish @ %s. Night end is @ %s!' %
(observation_end, night_end))
return False
else:
self._debuglog.debug('Block finish @ %s. Night end is @ %s!' %
(observation_end, night_end))
alt = float(site.raDecToAltAz(raDec, lst).alt)
airmass = 1. / np.cos(np.pi / 2. - alt * np.pi / 180.)
if blockpar.minairmass < airmass < blockpar.maxairmass:
self._debuglog.debug('\tairmass:%.3f' % airmass)
pass
else:
self._debuglog.warning(
'Target %s out of airmass range @ %.3f... (%f < %f < %f)' %
(target, time, blockpar.minairmass, airmass,
blockpar.maxairmass))
# return False
# FIXME
pass
# 2) check moon Brightness
moonPos = site.moonpos(dateTime)
moonBrightness = site.moonphase(dateTime) * 100.
if blockpar.minmoonBright < moonBrightness < blockpar.maxmoonBright:
self._debuglog.debug('\tMoon brightness:%.2f' % moonBrightness)
pass
elif moonPos.alt < 0.:
self._debuglog.warning(
'\tMoon bellow horizon. Moon brightness:%.2f' % moonBrightness)
else:
self._debuglog.warning('Wrong Moon Brightness... (%f < %f < %f)' %
(blockpar.minmoonBright, moonBrightness,
blockpar.maxmoonBright))
return False
# 3) check moon distance
moonRaDec = site.altAzToRaDec(moonPos, lst)
moonDist = raDec.angsep(moonRaDec)
if moonDist < blockpar.minmoonDist:
self._debuglog.warning(
'Object to close to the moon... '
'Target@ %s / Moon@ %s (moonDist = %f | minmoonDist = %f)' %
(raDec, moonRaDec, moonDist, blockpar.minmoonDist))
return False
else:
self._debuglog.debug('\tMoon distance:%.3f' % moonDist)
# 4) check seeing
if self["seeingmonitors"] is not None:
seeing = self.getSM().seeing()
if seeing > blockpar.maxseeing:
self._debuglog.warning(
'Seeing higher than specified... sm = %f | max = %f' %
(seeing, blockpar.maxseeing))
return False
elif seeing < 0.:
self._debuglog.warning('No seeing measurement...')
else:
self._debuglog.debug('Seeing %.3f' % seeing)
# 5) check cloud cover
if self["cloudsensors"] is not None:
pass
if self["weatherstations"] is not None:
pass
if external_checker is not None:
# Todo: add a 3rd option which is a function to check if program is ok from the algorithm itself.
pass
self._debuglog.debug('Target OK!')
return True
def getPositionRaDec(self):
return Position.fromRaDec(self._ascom.RightAscension, self._ascom.Declination, epoch=Epoch.NOW)
