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 _genericLongLat(long, lat):
try:
if not isinstance(int, Coord):
long = Coord.fromDMS(int)
else:
long = int.toDMS()
Position._checkRange(float(int), -180, 360)
except ValueError as e:
raise ValueError("Invalid LONGITUDE coordinate %s" % str(int))
except PositionOutsideLimitsError:
raise ValueError(
"Invalid LONGITUDE range %s. Must be between 0-360 deg or -180 - +180 deg."
% str(int))
try:
if not isinstance(lat, Coord):
lat = Coord.fromDMS(lat)
else:
lat = lat.toDMS()
Position._checkRange(float(lat), -90, 180)
except ValueError:
raise ValueError("Invalid LATITUDE coordinate %s" % str(lat))
except PositionOutsideLimitsError:
raise ValueError(
"Invalid LATITUDE range %s. Must be between 0-180 deg or -90 - +90 deg."
% str(lat))
return (int, lat)
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 fromAltAz(alt, az):
try:
if not isinstance(az, Coord):
az = Coord.fromDMS(az)
else:
az = az.toDMS()
Position._checkRange(float(az), -180, 360)
except ValueError as e:
raise ValueError("Invalid AZ coordinate %s" % str(az))
except PositionOutsideLimitsError:
raise ValueError(
"Invalid AZ range %s. Must be between 0-360 deg or -180 - +180 deg."
% str(az))
try:
if not isinstance(alt, Coord):
alt = Coord.fromDMS(alt)
else:
alt = alt.toDMS()
Position._checkRange(float(alt), -90, 180)
except ValueError as e:
raise ValueError("Invalid ALT coordinate %s" % str(alt))
except PositionOutsideLimitsError:
raise ValueError(
"Invalid ALT range %s. Must be between 0-180 deg or -90 - +90 deg."
% str(alt))
return Position((alt, az), system=System.TOPOCENTRIC)
def test_coord(self):
c = Config({"DMS": Coord.fromDMS(10), "HMS": Coord.fromHMS(10)})
assert c["DMS"].state == State.DMS
assert c["HMS"].state == State.HMS
c["DMS"] = 20
assert c["DMS"] == Coord.fromDMS(20)
c["HMS"] = 20
assert c["HMS"] == Coord.fromHMS(20)
assert c["HMS"] == Coord.fromDMS(20 * 15)
def test_coord (self):
c = Config({"DMS": Coord.fromDMS(10),
"HMS": Coord.fromHMS(10)})
assert c["DMS"].state == State.DMS
assert c["HMS"].state == State.HMS
c["DMS"] = 20
assert c["DMS"] == Coord.fromDMS(20)
c["HMS"] = 20
assert c["HMS"] == Coord.fromHMS(20)
assert c["HMS"] == Coord.fromDMS(20*15)
def find (self, near=None, limit=9999, **conditions):
self.useCat("II/183A/")
if conditions.get("closest", False):
limit = 1
self.useColumns("*POS_EQ_RA_MAIN,*POS_EQ_DEC_MAIN,*ID_MAIN,Vmag,_r", sortBy="_r")
else:
self.useColumns("*POS_EQ_RA_MAIN,*POS_EQ_DEC_MAIN,*ID_MAIN,Vmag,_r", sortBy="*POS_EQ_RA_MAIN")
if near:
self.useTarget(near, radius=conditions.get("radius", 45))
x = super(Landolt,self).find(limit)
for i in x:
RA = i.pop("*POS_EQ_RA_MAIN")
i["RA"] = Coord.fromHMS(str(RA))
DEC = i.pop("*POS_EQ_DEC_MAIN")
i["DEC"] = Coord.fromDMS(str(DEC))
ID = i.pop("*ID_MAIN")
i["ID"] = str(ID)
V = i.pop("Vmag")
i["V"] = str(V)
i.pop("_r")
return x
def _validateOffset(value):
try:
offset = Coord.fromAS(int(value))
except ValueError:
offset = Coord.fromDMS(value)
return offset
def getAz(self):
self._checkQuirk()
self.tty.setTimeout(10)
cmd = "POSICAO?"
self._write(cmd)
ack = self._readline()
# check timeout
if not ack:
raise IOError("Couldn't get azimuth after %d seconds." % 10)
# uC is going crazy
if ack == "INVALIDO":
raise IOError("Error getting dome azimuth (ack=INVALIDO).")
# get ack return
if ack.startswith("CUPULA="):
ack = ack[ack.find("=") + 1:]
if ack == "ERRO":
# FIXME: restart and try again
raise ChimeraException(
"Dome is in invalid state. Hard restart needed.")
# correct dome/telescope phase difference
az = int(math.ceil(int(ack) * self["az_resolution"]))
az -= self._az_shift
az = az % 360
return Coord.fromDMS(az)
def test_parse_dms (self):
coords = []
t_parse = 0
t_check = 0
for dd in range(-23, 24):
for mm in range(0, 60):
for ss in range(0, 60):
s = '%+03d:%02d:%06.3f' % (dd,mm,ss)
t = time.clock()
c = Coord.fromDMS(s)
t_parse += time.clock()-t
coords.append((s,c))
for coord in coords:
t = time.clock()
assert coord[0] == str(coord[1]), (coord[0], "!=", str(coord[1]))
t_check += time.clock()-t
print "#%d coords parsed in %.3fs (%.3f/s) and checked in %.3fs (%.3f/s) ..." % (len(coords), t_parse, len(coords)/t_parse,
t_check, len(coords)/t_check)
def getTargetDec(self):
self._write(":Gd#")
ret = self._readline()
ret = ret.replace('\xdf', ':')
return Coord.fromDMS(ret[:-1])
def getTargetDec(self):
self._write(":Gd#")
ret = self._readline()
ret = ret.replace('\xdf', ':')
return Coord.fromDMS(ret[:-1])
def test_parse_dms(self):
coords = []
t_parse = 0
t_check = 0
for dd in range(-23, 24):
for mm in range(0, 60):
for ss in range(0, 60):
s = '%+03d:%02d:%06.3f' % (dd, mm, ss)
t = time.clock()
c = Coord.fromDMS(s)
t_parse += time.clock() - t
coords.append((s, c))
for coord in coords:
t = time.clock()
assert coord[0] == str(coord[1]), (coord[0], "!=", str(coord[1]))
t_check += time.clock() - t
print "#%d coords parsed in %.3fs (%.3f/s) and checked in %.3fs (%.3f/s) ..." % (
len(coords), t_parse, len(coords) / t_parse, t_check,
len(coords) / t_check)
def find(self, near=None, limit=9999, **conditions):
self.useCat("II/183A/")
#self.useCat("II/118/")
if conditions.get("closest", False):
limit = 1
self.useColumns(
"*POS_EQ_RA_MAIN,*POS_EQ_DEC_MAIN,*ID_MAIN,Vmag,_r",
sortBy="_r")
else:
self.useColumns(
"*POS_EQ_RA_MAIN,*POS_EQ_DEC_MAIN,*ID_MAIN,Vmag,_r",
sortBy="*POS_EQ_RA_MAIN")
if near:
self.useTarget(near, radius=conditions.get("radius", 45))
x = super(Landolt, self).find(limit)
for i in x:
RA = i.pop("*POS_EQ_RA_MAIN")
i["RA"] = Coord.fromHMS(str(RA))
DEC = i.pop("*POS_EQ_DEC_MAIN")
i["DEC"] = Coord.fromDMS(str(DEC))
ID = i.pop("*ID_MAIN")
i["ID"] = str(ID)
V = i.pop("Vmag")
i["V"] = str(V)
i.pop("_r")
return x
def test_set_info (self):
m = self.m
try:
m.setLat("-22 32 03")
m.setLong("-45 34 57")
m.setDate(time.time())
m.setLocalTime(time.time())
m.setUTCOffset(3)
m.setLat(Coord.fromDMS("-22 32 03"))
m.setLong(Coord.fromDMS("-45 34 57"))
m.setDate(dt.date.today())
m.setLocalTime(dt.datetime.now().time())
m.setUTCOffset(3)
except Exception:
log.exception("error")
def setLong(self, coord): # converted to Astelco
if not isinstance(coord, Coord):
coord = Coord.fromDMS(coord)
cmdid = self._tpl.set(
'POINTING.SETUP.LOCAL.LONGITUDE', coord.D, wait=True)
ret = self._tpl.succeeded(cmdid)
if not ret:
raise AstelcoException("Invalid Longitude '%s'" % coord.D)
return True
def slewToAz(self, az):
if not isinstance(az, Coord):
az = Coord.fromDMS(az)
if int(az) >= 360:
az = az % 360
drv = self.getDriver()
drv.slewToAz(az)
def fromAltAz(alt, az):
try:
if not isinstance(az, Coord):
az = Coord.fromDMS(az)
else:
az = az.toDMS()
Position._checkRange(float(az), -180, 360)
except ValueError, e:
raise ValueError("Invalid AZ coordinate %s" % str(az))
def _genericLongLat(long, lat):
try:
if not isinstance(long, Coord):
long = Coord.fromDMS(long)
else:
long = long.toDMS()
Position._checkRange(float(long), -180, 360)
except ValueError, e:
raise ValueError("Invalid LONGITUDE coordinate %s" % str(long))
def _telescopeChanged (self, az):
if not isinstance(az, Coord):
az = Coord.fromDMS(az)
if self._needToMove(az):
self.log.debug("[control] adding %s to the queue (delta=%.2f)" % (az, abs(self.getAz()-az)))
self.queue.put(az)
else:
self.log.debug("[control] standing"
" (dome az=%.2f, tel az=%.2f, delta=%.2f.)" % (self.getAz(), az, abs(self.getAz()-az)))
def getDec(self):
self._write(":GD#")
ret = self._readline()
# meade bugs: same as getRa
if len(ret) > 10:
ret = ret[1:]
ret = ret.replace('\xdf', ':')
return Coord.fromDMS(ret[:-1])
def getDec(self):
self._write(":GD#")
ret = self._readline()
# meade bugs: same as getRa
if len(ret) > 10:
ret = ret[1:]
ret = ret.replace('\xdf', ':')
return Coord.fromDMS(ret[:-1])
def fromAltAz(alt, az):
try:
if not isinstance(az, Coord):
az = Coord.fromDMS(az)
else:
az = az.toDMS()
Position._checkRange(float(az), -180, 360)
except ValueError, e:
raise ValueError("Invalid AZ coordinate %s" % str(az))
def _genericLongLat(long, lat):
try:
if not isinstance(long, Coord):
long = Coord.fromDMS(long)
else:
long = long.toDMS()
Position._checkRange(float(long), -180, 360)
except ValueError, e:
raise ValueError("Invalid LONGITUDE coordinate %s" % str(long))
def setTargetDec(self, dec): # converted to Astelco
if not isinstance(dec, Coord):
dec = Coord.fromDMS(dec)
cmdid = self._tpl.set('OBJECT.EQUATORIAL.DEC', dec.D, wait=True)
ret = self._tpl.succeeded(cmdid)
if not ret:
raise AstelcoException("Invalid DEC '%s'" % dec)
return True
def _telescopeChanged(self, az):
if not isinstance(az, Coord):
az = Coord.fromDMS(az)
if self._needToMove(az):
self.log.debug("[control] adding %s to the queue." % az)
self.queue.put(az)
else:
self.log.debug("[control] telescope still in the slit, standing"
" (dome az=%.2f, tel az=%.2f, delta=%.2f.)" %
(self.getAz(), az, abs(self.getAz() - az)))
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 __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 slewToAz(self, az):
self._checkQuirk()
if not isinstance(az, Coord):
az = Coord.fromDMS(az)
# correct dome/telescope phase difference
dome_az = az.D + self._az_shift
if dome_az > 360:
raise InvalidDomePositionException("Cannot slew to %s. "
"Outside azimuth limits." % az)
dome_az = int (math.ceil (dome_az / self["az_resolution"]))
pstn = "CUPULA=%03d" % dome_az
self.tty.setTimeout (self["slew_timeout"])
self._write(pstn)
ack = self._readline ()
if ack == "INVALIDO":
raise IOError("Error trying to slew the dome to"
"azimuth '%s' (dome azimuth '%s')." % (az, dome_az))
# ok, we are slewing now
self._slewing = True
self.slewBegin(az)
# FIXME: add abort option here
fin = self._readline ()
if fin == "ALARME":
self.log.warning("Error while slewing dome. Some barcodes"
" couldn't be read correctly."
" Restarting the dome and trying again.")
self._restartDome()
return self.slewToAz(az)
if fin.startswith ("CUPULA="):
self._slewing = False
time.sleep (0.3) # FIXME: how much sleep we need?
self.slewComplete(self.getAz(), DomeStatus.OK)
else:
self._slewing = False
self.log.warning("Unknow error while slewing. "
"Received '%s' from dome. Restarting it." % fin)
self._restartDome()
return self.slewToAz(az)
def slewToAz(self, az):
self._checkQuirk()
if not isinstance(az, Coord):
az = Coord.fromDMS(az)
# correct dome/telescope phase difference
dome_az = az.D + self._az_shift
if dome_az > 360:
raise InvalidDomePositionException("Cannot slew to %s. "
"Outside azimuth limits." % az)
dome_az = int(math.ceil(dome_az / self["az_resolution"]))
pstn = "CUPULA=%03d" % dome_az
self.tty.setTimeout(self["slew_timeout"])
self._write(pstn)
ack = self._readline()
if ack == "INVALIDO":
raise IOError("Error trying to slew the dome to"
"azimuth '%s' (dome azimuth '%s')." % (az, dome_az))
# ok, we are slewing now
self._slewing = True
self.slewBegin(az)
# FIXME: add abort option here
fin = self._readline()
if fin == "ALARME":
self.log.warning("Error while slewing dome. Some barcodes"
" couldn't be read correctly."
" Restarting the dome and trying again.")
self._restartDome()
return self.slewToAz(az)
if fin.startswith("CUPULA="):
self._slewing = False
time.sleep(0.3) # FIXME: how much sleep we need?
self.slewComplete(self.getAz(), DomeStatus.OK)
else:
self._slewing = False
self.log.warning("Unknow error while slewing. "
"Received '%s' from dome. Restarting it." % fin)
self._restartDome()
return self.slewToAz(az)
def test_jog(self):
# FIXME: make a real test.
raise SkipTest()
print
dt = Coord.fromDMS("00:20:00")
start = self.tel.getPositionRaDec()
self.tel.moveNorth(dt, SlewRate.FIND)
print "North:", (start.ra - self.tel.getPositionRaDec().ra).AS, (
start.dec - self.tel.getPositionRaDec().dec).AS
start = self.tel.getPositionRaDec()
self.tel.moveSouth(dt, SlewRate.FIND)
print "South:", (start.ra - self.tel.getPositionRaDec().ra).AS, (
start.dec - self.tel.getPositionRaDec().dec).AS
start = self.tel.getPositionRaDec()
self.tel.moveWest(dt, SlewRate.FIND)
print "West :", (start.ra - self.tel.getPositionRaDec().ra).AS, (
start.dec - self.tel.getPositionRaDec().dec).AS
start = self.tel.getPositionRaDec()
self.tel.moveEast(dt, SlewRate.FIND)
print "East :", (start.ra - self.tel.getPositionRaDec().ra).AS, (
start.dec - self.tel.getPositionRaDec().dec).AS
start = self.tel.getPositionRaDec()
self.tel.moveNorth(dt, SlewRate.FIND)
self.tel.moveEast(dt, SlewRate.FIND)
print "NE :", (start.ra - self.tel.getPositionRaDec().ra).AS, (
start.dec - self.tel.getPositionRaDec().dec).AS
start = self.tel.getPositionRaDec()
self.tel.moveSouth(dt, SlewRate.FIND)
self.tel.moveEast(dt, SlewRate.FIND)
print "SE :", (start.ra - self.tel.getPositionRaDec().ra).AS, (
start.dec - self.tel.getPositionRaDec().dec).AS
start = self.tel.getPositionRaDec()
self.tel.moveNorth(dt, SlewRate.FIND)
self.tel.moveWest(dt, SlewRate.FIND)
print "NW :", (start.ra - self.tel.getPositionRaDec().ra).AS, (
start.dec - self.tel.getPositionRaDec().dec).AS
start = self.tel.getPositionRaDec()
self.tel.moveSouth(dt, SlewRate.FIND)
self.tel.moveWest(dt, SlewRate.FIND)
print "SW :", (start.ra - self.tel.getPositionRaDec().ra).AS, (
start.dec - self.tel.getPositionRaDec().dec).AS
def test_parsing_conversion_hipparcos(self):
"""Parsing and comparing a subset of the Hipparcos and Tycho Catalog"""
hipp = ascii.read(os.path.abspath(
os.path.join(os.path.dirname(__file__), 'hipparcos-tycho.dat')),
format="tab")
expected_ra = []
expected_ra_str = []
expected_dec = []
expected_dec_str = []
ra = []
ra_hms = []
dec = []
dec_dms = []
for row in hipp:
expected_ra_str.append(row[0].strip())
expected_dec_str.append(row[1].strip())
expected_ra.append(float(row[2]))
expected_dec.append(float(row[3]))
ra.append(Coord.fromD(str(row[2])))
dec.append(Coord.fromD(str(row[3])))
ra_hms.append(Coord.fromHMS(str(row[0])))
dec_dms.append(Coord.fromDMS(str(row[1])))
for i in range(len(hipp)):
assert expected_ra_str[i] == ra_hms[i].strfcoord("%(h)02d %(m)02d %(s)05.2f"), \
"ra: %s != coord ra: %s" % (expected_ra_str[i], ra_hms[i].strfcoord("%(h)02d %(m)02d %(s)05.2f"))
assert expected_dec_str[i] == dec_dms[i].strfcoord("%(d)02d %(m)02d %(s)04.1f"), \
"dec: %s != coord dec: %s" % (expected_dec_str[i], dec_dms[i].strfcoord("%(d)02d %(m)02d %(s)04.1f"))
# test conversion from D to D
assert TestCoord.equal(ra[i].D, expected_ra[i], e=1e-8), \
"ra: %.6f != coord ra: %.6f (%.6f)" % (expected_ra[i], ra[i].D, expected_ra[i]-ra[i].D)
assert TestCoord.equal(dec[i].D, expected_dec[i], e=1e-8), \
"dec: %.6f != coord dec: %.64f (%.6f)" % (expected_dec[i], dec[i].D, expected_dec[i]-dec[i].D)
# test conversion from DMS HMS to D
assert TestCoord.equal(ra_hms[i].D, expected_ra[i], e=1e-4), \
"ra: %.6f != coord ra: %.6f (%.6f)" % (expected_ra[i], ra_hms[i].D, expected_ra[i]-ra_hms[i].D)
assert TestCoord.equal(dec_dms[i].D, expected_dec[i], e=1e-4), \
"dec: %.6f != coord dec: %.64f (%.6f)" % (expected_dec[i], dec_dms[i].D, expected_dec[i]-dec_dms[i].D)
def setLong (self, coord):
if not isinstance (coord, Coord):
coord = Coord.fromDMS (coord)
self._write (":Sg%s#" % coord.strfcoord("%(d)03d\xdf%(m)02d"))
ret = self._readbool ()
if not ret:
raise MeadeException("Invalid Longitude '%s'" % long)
return True
def setLat(self, lat): # converted to Astelco
if not isinstance(lat, Coord):
lat = Coord.fromDMS(lat)
lat_float = float(lat.D)
cmdid = self._tpl.set(
'POINTING.SETUP.LOCAL.LATITUDE', float(lat_float), wait=True)
ret = self._tpl.succeeded(cmdid)
if not ret:
raise AstelcoException(
"Invalid Latitude '%s' ('%s')" % (lat, lat_float))
return True
def setTargetDec(self, dec):
if not isinstance (dec, Coord):
dec = Coord.fromDMS(dec)
self._write(":Sd%s#" % dec.strfcoord("%(d)02d\xdf%(m)02d:%(s)02d"))
ret = self._readbool()
if not ret:
raise MeadeException("Invalid DEC '%s'" % dec)
return True
def setTargetDec(self, dec):
if not isinstance(dec, Coord):
dec = Coord.fromDMS(dec)
self._write(":Sd%s#" % dec.strfcoord("%(d)02d\xdf%(m)02d:%(s)02d"))
ret = self._readbool()
if not ret:
raise MeadeException("Invalid DEC '%s'" % dec)
return True
def setLong(self, coord):
if not isinstance(coord, Coord):
coord = Coord.fromDMS(coord)
self._write(":Sg%s#" % coord.strfcoord("%(d)03d\xdf%(m)02d"))
ret = self._readbool()
if not ret:
raise MeadeException("Invalid Longitude '%s'" % long)
return True
def getAz(self):
self._write(":GZ#")
ret = self._readline()
ret = ret.replace('\xdf', ':')
c = Coord.fromDMS(ret[:-1])
if self['azimuth180Correct']:
if c.toD() >= 180:
c = c - Coord.fromD(180)
else:
c = c + Coord.fromD(180)
return c
def getAz(self):
self._write(":GZ#")
ret = self._readline()
ret = ret.replace('\xdf', ':')
c = Coord.fromDMS(ret[:-1])
if self['azimuth180Correct']:
if c.toD() >= 180:
c = c - Coord.fromD(180)
else:
c = c + Coord.fromD(180)
return c
def test_parsing_conversion_bsc(self):
"""Parsing and comparing to Vizier calculated values the entire 5th Bright Star Catalogue"""
bsc = asciidata.open(os.path.abspath(
os.path.join(os.path.dirname(__file__), 'bsc.dat')),
comment_char='#',
delimiter='\t')
expected_ra = []
expected_ra_str = []
expected_dec = []
expected_dec_str = []
ra = []
dec = []
for i in range(bsc.nrows):
expected_ra.append(bsc[0][i])
expected_dec.append(bsc[1][i])
expected_ra_str.append(bsc[2][i].strip())
expected_dec_str.append(bsc[3][i].strip())
ra.append(Coord.fromHMS(bsc[2][i]))
dec.append(Coord.fromDMS(bsc[3][i]))
for i in range(bsc.nrows):
# use e=0.0001 'cause its the maximum we can get with Vizier data (4 decimal places only)
# test conversion from HMS DMS to decimal
assert TestCoord.equal(
ra[i].D, expected_ra[i],
e=1e-4), "ra: %.6f != coord ra: %.6f (%.6f)" % (
expected_ra[i], ra[i].D, expected_ra[i] - ra[i].D)
assert TestCoord.equal(
dec[i].D, expected_dec[i],
e=1e-4), "dec: %.6f != coord dec: %.64f (%.6f)" % (
expected_dec[i], dec[i].D, expected_dec[i] - dec[i].D)
# test strfcoord implementation
assert expected_ra_str[i] == ra[i].strfcoord(
"%(h)02d %(m)02d %(s)04.1f"), "ra: %s != coord ra: %s" % (
expected_ra_str[i],
ra[i].strfcoord("%(h)02d %(m)02d %(s)04.1f"))
assert expected_dec_str[i] == dec[i].strfcoord(
"%(d)02d %(m)02d %(s)02.0f"), "dec: %s != coord dec: %s" % (
expected_dec_str[i],
dec[i].strfcoord("%(d)02d %(m)02d %(s)02.0f"))
def test_parsing_conversion_hipparcos (self):
"""Parsing and comparing a subset of the Hipparcos and Tycho Catalog"""
hipp = ascii.read(os.path.abspath(os.path.join(os.path.dirname(__file__), 'hipparcos-tycho.dat')), format="tab")
expected_ra = []
expected_ra_str = []
expected_dec = []
expected_dec_str = []
ra = []
ra_hms = []
dec = []
dec_dms = []
for row in hipp:
expected_ra_str.append(row[0].strip())
expected_dec_str.append(row[1].strip())
expected_ra.append(float(row[2]))
expected_dec.append(float(row[3]))
ra.append(Coord.fromD(str(row[2])))
dec.append(Coord.fromD(str(row[3])))
ra_hms.append(Coord.fromHMS(str(row[0])))
dec_dms.append(Coord.fromDMS(str(row[1])))
for i in range(len(hipp)):
assert expected_ra_str[i] == ra_hms[i].strfcoord("%(h)02d %(m)02d %(s)05.2f"), \
"ra: %s != coord ra: %s" % (expected_ra_str[i], ra_hms[i].strfcoord("%(h)02d %(m)02d %(s)05.2f"))
assert expected_dec_str[i] == dec_dms[i].strfcoord("%(d)02d %(m)02d %(s)04.1f"), \
"dec: %s != coord dec: %s" % (expected_dec_str[i], dec_dms[i].strfcoord("%(d)02d %(m)02d %(s)04.1f"))
# test conversion from D to D
assert TestCoord.equal(ra[i].D, expected_ra[i], e=1e-8), \
"ra: %.6f != coord ra: %.6f (%.6f)" % (expected_ra[i], ra[i].D, expected_ra[i]-ra[i].D)
assert TestCoord.equal(dec[i].D, expected_dec[i], e=1e-8), \
"dec: %.6f != coord dec: %.64f (%.6f)" % (expected_dec[i], dec[i].D, expected_dec[i]-dec[i].D)
# test conversion from DMS HMS to D
assert TestCoord.equal(ra_hms[i].D, expected_ra[i], e=1e-4), \
"ra: %.6f != coord ra: %.6f (%.6f)" % (expected_ra[i], ra_hms[i].D, expected_ra[i]-ra_hms[i].D)
assert TestCoord.equal(dec_dms[i].D, expected_dec[i], e=1e-4), \
"dec: %.6f != coord dec: %.64f (%.6f)" % (expected_dec[i], dec_dms[i].D, expected_dec[i]-dec_dms[i].D)
def slewToAz(self, az):
if not self._checkIdle(): # Verify if dome is idle
self.log.warning("Error, Dome busy.")
return
if not isinstance(az, Coord):
az = Coord.fromDMS(az)
# correct dome/telescope phase difference
dome_az = az.D + self._az_shift
if dome_az > 360:
raise InvalidDomePositionException("Cannot slew to %s. "
"Outside azimuth limits." % az)
if dome_az >= 270:
dome_az = int(math.ceil(dome_az / self["az_resolution"]))
dome_az += 666 # Values between 801 and 982, starting in 207 degrees
else:
dome_az = int(math.ceil(dome_az / self["az_resolution"]))
dome_az += 847
pstn = "MEADE DOMO MOVER = %03d" % dome_az
self._write(pstn)
ack = self._readline()
if ack != "ACK":
raise IOError("Error trying to slew the dome to"
"azimuth '%s' (dome azimuth '%s')." % (az, dome_az))
# ok, we are slewing now
self._slewing = True
self.slewBegin(az)
# FIXME: add abort option here
for x in range(120): # Tries 120 times
time.sleep(0.5) # Total of 60 seconds waiting
if self._checkIdle():
self._slewing = False
self.slewComplete(self.getAz(), DomeStatus.OK)
# break
return
if not self._checkIdle():
self.log.warning("Error, restarting Dome.")
self._restartDome()
def fromRaDec(ra, dec, epoch=Epoch.J2000):
try:
if type(ra) is str:
ra = Coord.fromHMS(ra)
elif isinstance(ra, Coord):
ra = ra.toHMS()
else:
try:
ra = Coord.fromH(float(ra))
ra = ra.toHMS()
except ValueError:
raise ValueError(
"Invalid RA coordinate type %s. Expected numbers, strings or Coords."
% str(type(ra)))
Position._checkRange(float(ra), 0, 360)
except ValueError as e:
raise ValueError("Invalid RA coordinate %s" % str(ra))
except PositionOutsideLimitsError:
raise ValueError(
"Invalid RA range %s. Must be between 0-24 hours or 0-360 deg."
% str(ra))
try:
if type(dec) is str:
dec = Coord.fromDMS(dec)
elif isinstance(dec, Coord):
dec = dec.toDMS()
else:
try:
dec = Coord.fromD(float(dec))
dec = dec.toDMS()
except ValueError:
raise ValueError(
"Invalid DEC coordinate type %s. Expected numbers, strings or Coords."
% str(type(dec)))
Position._checkRange(float(dec), -90, 360)
except ValueError as e:
raise ValueError("Invalid DEC coordinate %s" % str(dec))
except PositionOutsideLimitsError:
raise ValueError(
"Invalid DEC range %s. Must be between 0-360 deg or -90 - +90 deg."
% str(dec))
return Position((ra, dec), system=System.CELESTIAL, epoch=epoch)
def setLat (self, lat):
if not isinstance (lat, Coord):
lat = Coord.fromDMS (lat)
lat_str = lat.strfcoord("%(d)02d\xdf%(m)02d")
self._write (":St%s#" % lat_str)
ret = self._readbool ()
if not ret:
raise MeadeException("Invalid Latitude '%s' ('%s')" % (lat, lat_str))
return True
def setLat(self, lat):
if not isinstance(lat, Coord):
lat = Coord.fromDMS(lat)
lat_str = lat.strfcoord("%(d)02d\xdf%(m)02d")
self._write(":St%s#" % lat_str)
ret = self._readbool()
if not ret:
raise MeadeException("Invalid Latitude '%s' ('%s')" %
(lat, lat_str))
return True
def slewToAz(self, az):
if not isinstance(az, Coord):
az = Coord.fromDMS(az)
if az > 360:
raise InvalidDomePositionException("Cannot slew to %s. "
"Outside azimuth limits." % az)
self._abort.clear()
self._slewing = True
self.slewBegin(az)
self.log.info("Slewing to %s" % az)
# slew time ~ distance from current position
distance = abs(float(az - self._position))
if distance > 180:
distance = 360 - distance
self.log.info("Slew distance %.3f deg" % distance)
slew_time = distance * self._maxSlewTime
self.log.info("Slew time ~ %.3f s" % slew_time)
status = DomeStatus.OK
t = 0
while t < slew_time:
if self._abort.isSet():
self._slewing = False
status = DomeStatus.ABORTED
break
time.sleep(0.1)
t += 0.1
if status == DomeStatus.OK:
self._position = az # move :)
else:
# assume half movement in case of abort
self._position = self.position + distance / 2.0
self._slewing = False
self.slewComplete(self.getAz(), status)
def slewToAz(self, az):
if not isinstance(az, Coord):
az = Coord.fromDMS(az)
if az > 360:
raise InvalidDomePositionException("Cannot slew to %s. "
"Outside azimuth limits." % az)
self._abort.clear()
self._slewing = True
self.slewBegin(az)
self.log.info("Slewing to %s" % az)
# slew time ~ distance from current position
distance = abs(float(az - self._position))
if distance > 180:
distance = 360 - distance
self.log.info("Slew distance %.3f deg" % distance)
slew_time = distance * self._maxSlewTime
self.log.info("Slew time ~ %.3f s" % slew_time)
status = DomeStatus.OK
t = 0
while t < slew_time:
if self._abort.isSet():
self._slewing = False
status = DomeStatus.ABORTED
break
time.sleep(0.1)
t += 0.1
if status == DomeStatus.OK:
self._position = az # move :)
else:
# assume half movement in case of abort
self._position = self.position + distance / 2.0
self._slewing = False
self.slewComplete(self.getAz(), status)
def setTargetAz(self, az):
if not isinstance(az, Coord):
az = Coord.fromDMS(az)
self._write(":Sz%s#" %
az.strfcoord("%(d)03d\xdf%(m)02d:%(s)02d", signed=False))
ret = self._readbool()
if not ret:
raise MeadeException("Invalid Azimuth '%s'" %
az.strfcoord("%(d)03d\xdf%(m)02d"))
self._target_az = az
return True
def getAz(self):
self._write(":GZ#")
ret = self._readline()
ret = ret.replace('\xdf', ':')
c = Coord.fromDMS(ret[:-1])
if self['azimuth180Correct']:
self.log.debug('Initial azimuth: %s' % str(c.toDMS()))
if c.toD() > 180:
c = c - Coord.fromD(180)
else:
c = c + Coord.fromD(180)
self.log.debug('Final azimuth: %s' % str(c.toDMS()))
return c
def test_jog(self):
# FIXME: make a real test.
raise SkipTest()
print
dt = Coord.fromDMS("00:20:00")
start = self.tel.getPositionRaDec()
self.tel.moveNorth(dt, SlewRate.FIND)
print "North:", (start.ra - self.tel.getPositionRaDec().ra).AS, (start.dec - self.tel.getPositionRaDec().dec).AS
start = self.tel.getPositionRaDec()
self.tel.moveSouth(dt, SlewRate.FIND)
print "South:", (start.ra - self.tel.getPositionRaDec().ra).AS, (start.dec - self.tel.getPositionRaDec().dec).AS
start = self.tel.getPositionRaDec()
self.tel.moveWest(dt, SlewRate.FIND)
print "West :", (start.ra - self.tel.getPositionRaDec().ra).AS, (start.dec - self.tel.getPositionRaDec().dec).AS
start = self.tel.getPositionRaDec()
self.tel.moveEast(dt, SlewRate.FIND)
print "East :", (start.ra - self.tel.getPositionRaDec().ra).AS, (start.dec - self.tel.getPositionRaDec().dec).AS
start = self.tel.getPositionRaDec()
self.tel.moveNorth(dt, SlewRate.FIND)
self.tel.moveEast(dt, SlewRate.FIND)
print "NE :", (start.ra - self.tel.getPositionRaDec().ra).AS, (start.dec - self.tel.getPositionRaDec().dec).AS
start = self.tel.getPositionRaDec()
self.tel.moveSouth(dt, SlewRate.FIND)
self.tel.moveEast(dt, SlewRate.FIND)
print "SE :", (start.ra - self.tel.getPositionRaDec().ra).AS, (start.dec - self.tel.getPositionRaDec().dec).AS
start = self.tel.getPositionRaDec()
self.tel.moveNorth(dt, SlewRate.FIND)
self.tel.moveWest(dt, SlewRate.FIND)
print "NW :", (start.ra - self.tel.getPositionRaDec().ra).AS, (start.dec - self.tel.getPositionRaDec().dec).AS
start = self.tel.getPositionRaDec()
self.tel.moveSouth(dt, SlewRate.FIND)
self.tel.moveWest(dt, SlewRate.FIND)
print "SW :", (start.ra - self.tel.getPositionRaDec().ra).AS, (start.dec - self.tel.getPositionRaDec().dec).AS
def getAz(self):
if not self._checkIdle(): # Verify if dome is idle
self.log.warning("Error, Dome busy.")
return
self.tty.setTimeout(10)
cmd = "MEADE PROG STATUS"
self._write(cmd)
ack = self._readline()
# check timeout
if not ack:
self.log.warning("Dome timeout, restarting it.")
self._restartDome()
return self.getAz()
# raise IOError("Couldn't get azimuth after %d seconds." % 10)
# get ack return
if ack.startswith(" "):
ack = ack[8:11]
if ack == " ":
self.log.warning("No information on dome position. Move dome to initialize positioning")
ack = "000"
# correct dome/telescope phase difference
az = int(ack)
if az >= 847: # Values between 801 and 982, starting in 207 degrees
az -= 847
else:
az -= 666
az = int(math.ceil(az * self["az_resolution"]))
az -= self._az_shift
az %= 360
az += 4 # Ugly bugfixing for a dome in the dome controller.
return Coord.fromDMS(az)
def test_parsing_conversion_bsc (self):
"""Parsing and comparing to Vizier calculated values the entire 5th Bright Star Catalogue"""
bsc = ascii.read(os.path.abspath(os.path.join(os.path.dirname(__file__), 'bsc.dat')), format="tab", converters={})
expected_ra = []
expected_ra_str = []
expected_dec = []
expected_dec_str = []
ra = []
dec = []
for row in bsc:
expected_ra.append(row[0])
expected_dec.append(row[1])
expected_ra_str.append(row[2].strip())
expected_dec_str.append(row[3].strip())
ra.append(Coord.fromHMS(str(row[2])))
dec.append(Coord.fromDMS(str(row[3])))
for i in range(len(bsc)):
# use e=0.0001 'cause its the maximum we can get with Vizier data (4 decimal places only)
# test conversion from HMS DMS to decimal
assert TestCoord.equal(ra[i].D, expected_ra[i], e=1e-4), \
"ra: %.6f != coord ra: %.6f (%.6f)" % (expected_ra[i], ra[i].D, expected_ra[i]-ra[i].D)
assert TestCoord.equal(dec[i].D, expected_dec[i], e=1e-4), \
"dec: %.6f != coord dec: %.64f (%.6f)" % (expected_dec[i], dec[i].D, expected_dec[i]-dec[i].D)
# test strfcoord implementation
assert expected_ra_str[i] == ra[i].strfcoord("%(h)02d %(m)02d %(s)04.1f"), \
"ra: %s != coord ra: %s" % (expected_ra_str[i], ra[i].strfcoord("%(h)02d %(m)02d %(s)04.1f"))
assert expected_dec_str[i] == dec[i].strfcoord("%(d)02d %(m)02d %(s)02.0f"), \
"dec: %s != coord dec: %s" % (expected_dec_str[i], dec[i].strfcoord("%(d)02d %(m)02d %(s)02.0f"))
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 setTargetAz(self, az):
if not isinstance (az, Coord):
az = Coord.fromDMS (az)
if self['azimuth180Correct']:
if az.toD() >= 180:
az = az - Coord.fromD(180)
else:
az = az + Coord.fromD(180)
self._write (":Sz%s#" % az.strfcoord("%(d)03d\xdf%(m)02d:%(s)02d", signed=False))
ret = self._readbool()
if not ret:
raise MeadeException("Invalid Azimuth '%s'" % az.strfcoord("%(d)03d\xdf%(m)02d"))
self._target_az = az
return True
def setTargetAz(self, az): # converted to Astelco
if not isinstance(az, Coord):
az = Coord.fromDMS(az)
if self['azimuth180Correct']:
if az.toD() >= 180:
az = az - Coord.fromD(180)
else:
az = az + Coord.fromD(180)
cmdid = self._tpl.set('OBJECT.HORIZONTAL.AZ', az.D, wait=True)
ret = self._tpl.succeeded(cmdid)
if not ret:
raise AstelcoException(
"Invalid Azimuth '%s'" % az.strfcoord("%(d)03d\xdf%(m)02d"))
self._target_az = az
return True
def getAz(self):
self._checkQuirk ()
self.tty.setTimeout (10)
cmd = "POSICAO?"
self._write(cmd)
ack = self._readline ()
# check timeout
if not ack:
self.log.warning("Dome timeout, restarting it.")
self._restartDome()
return self.getAz()
#raise IOError("Couldn't get azimuth after %d seconds." % 10)
# uC is going crazy
if ack == "INVALIDO":
raise IOError("Error getting dome azimuth (ack=INVALIDO).")
# get ack return
if ack.startswith("CUPULA="):
ack = ack[ack.find("=")+1:]
if ack == "ERRO":
self.log.warning("Dome position error, restarting it.")
self._restartDome()
return self.getAz()
# correct dome/telescope phase difference
az = int(math.ceil(int(ack)*self["az_resolution"]))
az -= self._az_shift
az = az % 360
return Coord.fromDMS(az)
telescope_platescale = 50 # arcsec/mm
# 2 - Autoguider center
# For an SBIG ST7XME the parameters of the offset between the CCD and the guider are:
guider_offset = {'x': 0, 'y': 6.27} # in mm
guider_size = {'x': 4.86, 'y': 3.66, 'x_px': 657, 'y_px': 495} # in mm / px and pixels
guider_pixelsize = {'x': 0.0074, 'y': 0.0074} # in mm
guider_pixelsize.update({'x_ang': telescope_platescale * guider_pixelsize['x'], # in mm
'y_ang': telescope_platescale * guider_pixelsize['y']}) # in arcsec / px
# For plotting purposes
ccd_size = {'x': 6.89, 'y': 4.59} # in mm
ccd_pixelsize = {'x': 0.009, 'y': 0.009} # in mm
# Get a DSS Image...
ra = Coord.fromDMS("12 53 37.08")
dec = Coord.fromDMS("-60 21 22.7")
img = get_dss(ra, dec, 60, 60)
# fits.writeto('test.fits', img)
#img = fits.getdata('test.fits')
img = np.array(np.copy(img), dtype=np.float32)
# Image sizes in pixels
imsize = int(round(guider_size['x'] / guider_pixelsize['x'])), int(round(guider_size['y'] / guider_pixelsize['y']))
# img = imresize(img, imsize)
# Image sizes in arcmins
aux_width = guider_size['x'] * telescope_platescale / 60
aux_height = guider_size['y'] * telescope_platescale / 60
# TODO: DELME
img_scale = 60 / 35.3 # in arcsec / pix
imsize = img.shape[0], img.shape[1]
def getLong(self):
self._write(":Gg#")
ret = self._readline()
ret = ret.replace('\xdf', ':')[:-1]
return Coord.fromDMS(ret)
ra = ra.toHMS()
except ValueError:
raise ValueError(
"Invalid RA coordinate type %s. Expected numbers, strings or Coords." % str(type(ra)))
Position._checkRange(float(ra), 0, 360)
except ValueError, e:
raise ValueError("Invalid RA coordinate %s" % str(ra))
except PositionOutsideLimitsError:
raise ValueError(
"Invalid RA range %s. Must be between 0-24 hours or 0-360 deg." % str(ra))
try:
if type(dec) == StringType:
dec = Coord.fromDMS(dec)
elif isinstance(dec, Coord):
dec = dec.toDMS()
else:
try:
dec = Coord.fromD(float(dec))
dec = dec.toDMS()
except ValueError:
raise ValueError(
"Invalid DEC coordinate type %s. Expected numbers, strings or Coords." % str(type(dec)))
Position._checkRange(float(dec), -90, 360)
except ValueError, e:
raise ValueError("Invalid DEC coordinate %s" % str(dec))
except PositionOutsideLimitsError:
