sidereal.py"> ] >
&py;: Internal maintenance specification &py;: Internal specification John W. Shipman
tcc-doc@nmt.edu
$Revision: 1.43 $ $Date: 2008/01/01 01:55:56 $ &py; is a Python module to perform certain astronomical calculations. This document contains and describes the implementation of the module. This publication is available in Web form and also as a PDF document. Please forward any comments to tcc-doc@nmt.edu.
Introduction This document contains the source code for the &py; module. The technique of embedding the code in a document that explains its function is called literate programming; see the author's Lightweight Literate Programming page. The reader is assumed to be familiar with the Python programming language, including object-oriented programming. Some familiarity with the problem domain—spherical astronomy—will also be useful.
References The primary reference is Peter Duffett-Smith's Practical Astronomy with Your Calculator. For a full citation, see the specification. Other useful online references: Documentation for Python's math module. Documentation for Python's datetime module.
Online files Relevant online files: &py;: The Python source for the module. siderealims.xml: The DocBook source for this document.
<code >jd</code >: Convert date and time to Julian date Most of the work in this standalone script is checking and converting the command line arguments. We'll make heavy use of Python's re regular expression package.
Prologue #!/usr/bin/env python #================================================================ # jd: Convert date and time to Julian date # For documentation, see: # &selfURL; #----------------------------------------------------------------
Imports We'll need the standard Python sys module to get at command line arguments and I/O streams. #================================================================ # Imports #---------------------------------------------------------------- import sys In addition to the &py; module, we'll need Python's datetime package required by the JulianDate class. import sidereal import datetime
<code >main()</code > The main program first processes its command line arguments. Then, if all is well, it converts them to a JulianDate and displays that as a float. # - - - m a i n def main(): """jd main program. """ #-- 1 -- # [ if the arguments in sys.argv are valid -> # dt := a datetime.datetime instance representing the # date and time expressed in those arguments ] dt = argCheck() #-- 2 -- # [ jd := a JulianDate instance representing dt ] jd = sidereal.JulianDate.fromDatetime ( dt ) #-- 3 -- print float(jd)
<code >argCheck()</code >: Check command line arguments This function does all checking of command line arguments, and boils them down to a datetime.datetime instance. # - - - a r g C h e c k def argCheck(): """Check and convert the command line argument(s). """ The command line arguments in sys.argv[1:] can take either of two forms: A single argument, consisting of an ISO standard date, optionally followed by letter “T” (in either case) and a time, which may omit minutes and seconds; or, Two arguments: the first is an ISO date, and the second is the time in the same form as part after the “T” in the single-argument case. In the first case, we use to parse the single argument; in the second, we use and and then combine them into a datetime.datetime instance. #-- 1 -- # [ argList := the command line arguments ] argList = sys.argv[1:] #-- 2 -- # [ if (len(argList)==1) and argList[0] is a valid # date-time string -> # dt := that date-time as a datetime.datetime instance # else if (len(argList)==2) and (argList[0] is a valid # date) and (argList[1] is a valid time) -> # dt := a datetime.datetime representing that date # and time # else -> # sys.stderr +:= error message # stop execution ] if len(argList) == 1: try: dt = sidereal.parseDatetime ( argList[0] ) except SyntaxError, detail: usage ( "Invalid date-time: %s" % detail ) elif len(argList) == 2: try: date = sidereal.parseDate ( argList[0] ) except SyntaxError, detail: usage ( "Invalid date: %s" % detail ) try: time = sidereal.parseTime ( argList[1] ) except SyntaxError, detail: usage ( "Invalid time: %s" % detail ) dt = date.combine ( date, time ) else: usage ( "Incorrect number of arguments." ) #-- 3 -- return dt
<code >usage()</code >: Print a usage message and stop # - - - u s a g e def usage ( *L ): """Print a usage message and stop. [ L is a list of strings -> sys.stderr +:= (usage message) + (elements of L, concatenated) stop execution ] """ print >>sys.stderr, "*** Usage:" print >>sys.stderr, "*** jd yyyy-mm-dd[Thh[:mm[:ss]]]" print >>sys.stderr, "*** or:" print >>sys.stderr, "*** jd yyyy-mm-dd hh[:mm[:ss]]" print >>sys.stderr, "*** Error: %s" % "".join(L) raise SystemExit
Epilogue #================================================================ # Epilogue #---------------------------------------------------------------- if __name__ == "__main__": main()
<code >conjd</code >: Convert Julian date to date and time This script takes one command line argument, a Julian date as a float, and converts it to civil units.
Prologue #!/usr/bin/env python #================================================================ # conjd: Convert Julian date to date and time # For documentation, see: # &selfURL; #----------------------------------------------------------------
Imports Modules needed include the standard sys module and of course &py;. #================================================================ # Imports #---------------------------------------------------------------- import sys from sidereal import *
<code >main()</code > There are only two possible error conditions: wrong number of command line arguments; the argument is not a float. # - - - m a i n def main(): """conjd main program. """ #-- 1 -- # [ if sys.argv[1:] is a single float -> # j := that float # else -> # sys.stderr +:= error message # stop execution ] argList = sys.argv[1:] if len(argList) != 1: usage ( "Wrong argument count." ) else: try: j = float ( argList[0] ) except ValueError, detail: usage ( "Invalid argument: %s" % detail ) First we make j into a JulianDate instance. Then we use the .datetime() method on that instance to get a regular datetime.datetime instance. Final output is produced by applying str() to the datetime, which produces an ISO date. #-- 2 -- # [ jd := a JulianDate instance for Julian date j ] jd = JulianDate ( j ) #-- 3 -- # [ dt := jd as a datetime.datetime instance ] dt = jd.datetime() #-- 4 -- # [ sys.stdout +:= dt in ISO form ] print str(dt)
<code >usage()</code >: Write an error message and terminate # - - - u s a g e def usage ( *L ): """Write a usage message and stop. [ L is a list of strings -> sys.stderr +:= (usage message) + (joined elements of L) stop execution ] """ print >>sys.stderr, "*** Usage:" print >>sys.stderr, "*** conjd NNNNNNN.NN..." print >>sys.stderr, "*** where NNNNNNN.NN is the Julian date." print >>sys.stderr, "*** Error: %s" % "".join(L) raise SystemExit
Epilogue #================================================================ # Epilogue #---------------------------------------------------------------- if __name__ == "__main__": main()
<code >rdaa</code >: Equatorial to horizon coordinates For a given celestial position in equatorial coordinates, and a given observer's place and time, this script reports the position in horizon coordinates.
Prologue #!/usr/bin/env python #================================================================ # rdaa: Convert right ascension/declination to azimuth/altitude # For documentation, see: # &selfURL; #----------------------------------------------------------------
Imports We'll need the usual sys module for the command line arguments and I/O streams, and the regular expression module re for some parsing. #================================================================ # Imports #---------------------------------------------------------------- import sys, re We also need the sidereal package. import sidereal
Constants We'll need a pre-compiled regular expression to search for the plus or minus sign that separates the right ascension and declination on the command line. The “-” is escaped because otherwise it has special meaning inside “[...]” regular expressions. #================================================================ # Manifest consants #---------------------------------------------------------------- SIGN_PAT = re.compile ( r'[\-+]' )
<code >main()</code > The main sequence comes down to three steps: check and convert the command line arguments; find the local sidereal time; and then find the horizon coordinates. # - - - - - m a i n def main(): """Main program for rdaa. """ #-- 1 -- # [ if sys.argv contains a valid set of command line # arguments -> # raDec := the right ascension and declination as # a sidereal.RADec instance # latLon := the observer's location as a # sidereal.LatLon instance # dt := the observer's date and time as a # datetime.datetime instance # else -> # sys.stderr +:= error message # stop execution ] raDec, latLon, dt = checkArgs() Since the time specified might have a time zone attached, we'll need to convert it to UTC. #-- 2 -- # [ if dt has no time zone information -> # utc := dt # else -> # utc := the UTC equivalent to dt ] if ( (dt.tzinfo is None) or (dt.utcoffset() is None) ): utc = dt else: utc = dt - dt.utcoffset() Just for convenience and user reference, we'll compute and display the observer's local sidereal time. #-- 3 -- # [ sys.stdout +:= local sidereal time for dt and latLon ] gst = sidereal.SiderealTime.fromDatetime ( utc ) lst = gst.lst ( latLon.lon ) print "Equatorial coordinates:", raDec print "Observer's location:", latLon print "Observer's time:", dt print "Local sidereal time is", lst Now find the hour angle, convert to horizon coordinates, and print the result. #-- 4 -- # [ h := hour angle for raDec at time (utc) and longitude # (latLon.lon) ] h = raDec.hourAngle ( utc, latLon.lon ) #-- 5 -- # [ aa := horizon coordinates of raDec at hour angle h # as a sidereal.AltAz instance ] aa = raDec.altAz ( h, latLon.lat ) #-- 6 -- print "Horizon coordinates:", aa
<code >checkArgs()</code >: Process command-line arguments # - - - c h e c k A r g s def checkArgs(): """Process all command line arguments. [ if sys.argv[1:] is a valid set of command line arguments -> return (raDec, latLon, dt) where raDec is a set of celestial coordinates as a sidereal.RADec instance, latLon is position as a sidereal.LatLon instance, and dt is a datetime.datetime instance else -> sys.stderr +:= error message stop execution ] """ There should be exactly four arguments: The combined right ascension and declination, separated by the mandatory “+” or “-”. The latitude, as an angle followed by “n” or “s” (case-insensitive). The longitude, as an angle followed by “e” or “w” (case-insensitive). The timestamp, as a combined date-time string. #-- 1 -- # [ if sys.argv[1:] has exactly four elements -> # rawRADec, rawLat, rawLon, rawDT := those elements # else -> # sys.stderr +:= error message # stop execution ] argList = sys.argv[1:] if len(argList) != 4: usage ("Incorrect command line argument count." ) else: rawRADec, rawLat, rawLon, rawDT = argList The work of checking the first argument is delegated to subsidiary routines: . For the rest, standard parsing functions exist: , , and . #-- 2 -- # [ if rawRADec is a valid set of equatorial coordinates -> # raDec := those coordinates as a sidereal.RADec instance # else -> # sys.stderr +:= error message # stop execution ] raDec = checkRADec ( rawRADec ) #-- 3 -- # [ if rawLat is a valid latitude -> # lat := that latitude in radians # else -> # sys.stderr +:= error message # stop execution ] try: lat = sidereal.parseLat ( rawLat ) except SyntaxError, detail: usage ( "Invalid latitude: %s" % detail ) #-- 4 -- # [ if rawLon is a valid longitude -> # lon := that longitude in radians # else -> # sys.stderr +:= error message # stop execution ] try: lon = sidereal.parseLon ( rawLon ) except SyntaxError, detail: usage ( "Invalid longitude: %s" % detail ) #-- 5 -- # [ if rawDT is a valid date-time string -> # dt := that date-time as a datetime.datetime instance # else -> # sys.stderr +:= error message # stop execution ] try: dt = sidereal.parseDatetime ( rawDT ) except SyntaxError, detail: usage ( "Invalid timestamp: %s" % detail ) #-- 6 -- latLon = sidereal.LatLon ( lat, lon ) return (raDec, latLon, dt)
<code >usage()</code >: Print a message and stop # - - - u s a g e def usage ( *L ): """Print a usage message and stop. [ L is a list of strings -> sys.stderr +:= (usage message) + (elements of L, concatenated) stop execution ] """ print >>sys.stderr, "*** Usage:" print >>sys.stderr, "*** rdaa RA+dec lat lon datetime" print >>sys.stderr, "*** Or:" print >>sys.stderr, "*** rdaa RA-dec lat lon datetime" print >>sys.stderr, "*** Error: %s" % "".join(L) raise SystemExit
<code >checkRADec</code >: Check equatorial coordinates # - - - c h e c k R A D e c def checkRADec ( rawRADec ): """Check and convert a pair of equatorial coordinates. [ rawRADec is a string -> if rawRADec is a valid set of equatorial coordinates -> return those coordinates as a sidereal.RADec instance else -> sys.stderr +:= error message stop execution ] """ A set of equatorial coordinates consists of a quantity in hours, a “+” or “-” sign, and a declination as an angle. So we'll start by finding and saving the sign and breaking the string into its two parts. The .search() method of a precompiled regular expression searches for that pattern anywhere in a string. For SIGN_PAT, see . #-- 1 -- # [ if rawRADec contains either a '+' or a '-' -> # m := a re.match instance describing the first matching # character # else -> # sys.stderr +:= error message # stop execution ] m = SIGN_PAT.search ( rawRADec ) if m is None: usage ( "Equatorial coordinates must be separated by " "'+' or '-'." ) #-- 2 -- # [ rawRA := rawRADec up to the match described by m # sign := characters matched by m # rawDec := rawRADec past the match described by m ] rawRA = rawRADec[:m.start()] sign = m.group() rawDec = rawRADec[m.end():] To convert the raw RA, we'll use . #-- 3 -- # [ if rawRA is a valid hours expression -> # ra := rawRA as radians # else -> # sys.stderr +:= error message # stop execution ] try: raHours = sidereal.parseHours ( rawRA ) ra = sidereal.hoursToRadians ( raHours ) except SyntaxError, detail: usage ( "Right ascension '%s' should have the form " "'NNh[NNm[NN.NNNs]]'." % rawRA ) To convert the raw declination, we'll use . #-- 4 -- # [ if rawDec is a valid angle expression -> # absDec := that angle in radians # sys.stderr +:= error message # stop execution ] try: absDec = sidereal.parseAngle ( rawDec ) except SyntaxError, detail: usage ( "Right ascension '%s' should have the form " "'NNd[NNm[NN.NNNs]]'." % rawDec ) All that remains is to attach the sign to the declination, wrap both coordinates in an RADec instance, and return it. #-- 5 -- if sign == '-': dec = - absDec else: dec = absDec #-- 6 -- return sidereal.RADec ( ra, dec )
Epilogue #================================================================ # Epilogue #---------------------------------------------------------------- if __name__ == "__main__": main()
<code >aard</code >: Horizon to celestial coordinates This script is structurally nearly identical to , so the comments will be fairly skeletal here except in spots where the scripts differ.
Prologue #!/usr/bin/env python #================================================================ # aard: Convert azimuth/altitude to right ascension/declination # For documentation, see: # &selfURL; #----------------------------------------------------------------
Imports #================================================================ # Imports #---------------------------------------------------------------- import sys, re import sidereal
Constants #================================================================ # Manifest consants #---------------------------------------------------------------- SIGN_PAT = re.compile ( r'[\-+]' )
<code >main()</code > As with , first we check out the command line arguments, then convert from horizon to celestial coordinates and print the result. # - - - - - m a i n def main(): """Main program for aard. """ #-- 1 -- # [ if sys.argv contains a valid set of command line # arguments -> # altAz := the azimuth and altitude as # a sidereal.AltAz instance # latLon := the observer's location as a # sidereal.LatLon instance # dt := the observer's date and time as a # datetime.datetime instance # else -> # sys.stderr +:= error message # stop execution ] altAz, latLon, dt = checkArgs() #-- 2 -- # [ if dt has no time zone information -> # utc := dt # else -> # utc := the UTC equivalent to dt ] if ( (dt.tzinfo is None) or (dt.utcoffset() is None) ): utc = dt else: utc = dt - dt.utcoffset() Display the local sidereal time in case the observer is interested. #-- 3 -- # [ sys.stdout +:= local sidereal time for dt and latLon ] gst = sidereal.SiderealTime.fromDatetime ( utc ) lst = gst.lst ( latLon.lon ) print "Horizon coordinates:", altAz print "Observer's location:", latLon print "Observer's time:", dt print "Local sidereal time is", lst Here is where this script diverges from . To convert from horizon to equatorial coordinates, you need a local sidereal time and an observer's location. #-- 4 -- # [ raDec := equatorial coordinates of self for local # sidereal time (lst) and location (latLon) ] raDec = altAz.raDec ( lst, latLon ) #-- 5 -- print "Equatorial coordinates:", raDec
<code >checkArgs()</code >: Process command line arguments This is pretty similar to , except that the first item is an azimuth, sign, and altitude. # - - - c h e c k A r g s def checkArgs(): """Process all command line arguments. [ if sys.argv[1:] is a valid set of command line arguments -> return (altAz, latLon, dt) where altAz is a set of horizon coordinates as a sidereal.AltAz instance, latLon is position as a sidereal.LatLon instance, and dt is a datetime.datetime instance else -> sys.stderr +:= error message stop execution ] """ #-- 1 -- # [ if sys.argv[1:] has exactly four elements -> # rawAltAz, rawLat, rawLon, rawDT := those elements # else -> # sys.stderr +:= error message # stop execution ] argList = sys.argv[1:] if len(argList) != 4: usage ("Incorrect command line argument count." ) else: rawAltAz, rawLat, rawLon, rawDT = argList For the checking of the first argument, see . The rest are as in . #-- 2 -- # [ if rawAltAz is a valid set of horizon coordinates -> # altAz := those coordinates as a sidereal.AltAz instance altAz = checkAltAz ( rawAltAz ) #-- 3 -- # [ if rawLat is a valid latitude -> # lat := that latitude in radians # else -> # sys.stderr +:= error message # stop execution ] try: lat = sidereal.parseLat ( rawLat ) except SyntaxError, detail: usage ( "Invalid latitude: %s" % detail ) #-- 4 -- # [ if rawLon is a valid longitude -> # lon := that longitude in radians # else -> # sys.stderr +:= error message # stop execution ] try: lon = sidereal.parseLon ( rawLon ) except SyntaxError, detail: usage ( "Invalid longitude: %s" % detail ) #-- 5 -- # [ if rawDT is a valid date-time string -> # dt := that date-time as a datetime.datetime instance # else -> # sys.stderr +:= error message # stop execution ] try: dt = sidereal.parseDatetime ( rawDT ) except SyntaxError, detail: usage ( "Invalid timestamp: %s" % detail ) #-- 6 -- latLon = sidereal.LatLon ( lat, lon ) return (altAz, latLon, dt)
<code >usage()</code >: Print a message and stop # - - - u s a g e def usage ( *L ): """Print a usage message and stop. [ L is a list of strings -> sys.stderr +:= (usage message) + (elements of L, concatenated) stop execution ] """ print >>sys.stderr, "*** Usage:" print >>sys.stderr, "*** aard az+alt lat lon datetime" print >>sys.stderr, "*** Error: %s" % "".join(L) raise SystemExit
<code >checkAltAz()</code >: Validate horizon coordinates # - - - c h e c k A l t A z def checkAltAz ( rawAltAz ): """Check and convert a pair of horizon coordinates. [ rawAltAz is a string -> if rawAltAz is a valid set of horizon coordinates -> return those coordinates as a sidereal.AltAz instance else -> sys.stderr +:= error message stop execution ] """ This function is quite similar to : it looks for the plus or minus sign separating the azimuth from the altitude, using SIGN_PAT. Then the two parts are processed by . #-- 1 -- # [ if rawAltAz contains either a '+' or a '-' -> # m := a re.match instance describing the first matching # character # else -> # sys.stderr +:= error message # stop execution ] m = SIGN_PAT.search ( rawAltAz ) if m is None: usage ( "Equatorial coordinates must be separated by " "'+' or '-'." ) #-- 2 -- # [ rawAz := rawAltAz up to the match described by m # sign := characters matched by m # rawAlt := rawAltAz past the match described by m ] rawAz = rawAltAz[:m.start()] sign = m.group() rawAlt = rawAltAz[m.end():] #-- 3 -- # [ if rawAz is a valid angle -> # az := that angle as radians # else -> # sys.stderr +:= error message # stop execution ] try: az = sidereal.parseAngle ( rawAz ) except SyntaxError, detail: usage ( "Azimuth '%s' should have the form " "'NNNd[NNm[NN.NNNs]]'." % rawAz ) #-- 4 -- # [ if rawAlt is a valid angle -> # alt := that angle as radians # else -> # sys.stderr +:= error message # stop execution ] try: absAlt = sidereal.parseAngle ( rawAlt ) except SyntaxError, detail: usage ( "Altitude '%s' should have the form " "'NNd[NNm[NN.NNNs]]'." % rawAlt ) #-- 5 -- if sign == '-': alt = - absAlt else: alt = absAlt #-- 6 -- return sidereal.AltAz ( alt, az )
Epilogue #================================================================ # Epilogue #---------------------------------------------------------------- if __name__ == "__main__": main()
&py;: Prologue The &py; module begins with a documentation string that refers the reader back to this document. """&spy;: A Python module for astronomical calculations. For documentation, see: &selfURL; """
Imports This module relies on several Python library modules. First, we'll need all the standard trig functions and other math from the math module. #================================================================ # Imports #---------------------------------------------------------------- from math import * Next, we'll need the Python regular expression module. import re Python's standard datetime module, available since Python version 2.3, contains a full set of function for manipulating dates and times. There are references to this module's datetime, date, and time objects throughout this module. Refer to the online documentation for datetime. import datetime
Manifest constants Names of constants are in capital letters with “_” between words.
<code >FIRST_GREGORIAN_YEAR</code > The year in which we changed from the flawed Julian calendar to the modern Gregorian calendar. #================================================================ # Manifest constants #---------------------------------------------------------------- FIRST_GREGORIAN_YEAR = 1583
<code >TWO_PI</code > Number of radians in a circle; used for normalizing angles. TWO_PI = 2.0 * pi
<code >PI_OVER_12</code > Multiply hours (one hour is 15°) by this value to convert to radians: there are 24 hours in 2π radians. PI_OVER_12 = pi / 12.0
<code >JULIAN_BIAS</code > This value is subtracted from Julian dates internally in the JulianDate class in order to get more precision. JULIAN_BIAS = 2200000 # 2,200,000
<code >SIDEREAL_A</code >: Sidereal time conversion factor This constant is used in two places: and . In Duffett-Smith, it is defined on page 23. SIDEREAL_A = 0.0657098
<code >FLOAT_PAT</code >: Regular expression for a floating-point number This compiled regular expression matches a floating-point number: one or more digits, followed optionally by a decimal point and zero or more digits. FLOAT_PAT = re.compile ( r'\d+' # Matches one or more digits r'(' # Start optional fraction r'[.]' # Matches the decimal point r'\d+' # Matches one or more digits r')?' ) # End optional group
<code >D_PAT</code >: Degrees code This regular expression matches “d” or “D”. It is used in parsing angles. D_PAT = re.compile ( r'[dD]' )
<code >M_PAT</code >: Minutes code This regular expression matches “m” or “M”. It is used in parsing angles. M_PAT = re.compile ( r'[mM]' )
<code >S_PAT</code >: Seconds code This regular expression matches “s” or “S”. It is used in parsing angles. S_PAT = re.compile ( r'[sS]' )
<code >H_PAT</code >: Hours code This regular expression matches “h” or “H”. It is used in parsing quantities in hours. H_PAT = re.compile ( r'[hH]' )
<code >NS_PAT</code >: Latitude suffix This regular expression is for the characters that describe north or south latitude. NS_PAT = re.compile ( r'[nNsS]' )
<code >EW_PAT</code >: Longitude suffix A regular expression for the characters that describe east or west longitude. EW_PAT = re.compile ( r'[eEwW]' )
Exported functions These functions are available to users of the module.
<code >hoursToRadians()</code >: Convert hours to radians # - - - h o u r s T o R a d i a n s def hoursToRadians ( hours ): """Convert hours (15 degrees) to radians. """ return hours * PI_OVER_12
<code >radiansToHours()</code >: Convert hours to radians # - - - r a d i a n s T o H o u r s def radiansToHours ( radians ): """Convert radians to hours (15 degrees). """ return radians / PI_OVER_12
<code >hourAngleToRA()</code >: Convert an hour angle to right ascension For a given hour angle h, a given time ut, and an observer's longitude eLong, this function returns the right ascension in radians. # - - - h o u r A n g l e T o R A def hourAngleToRA ( h, ut, eLong ): """Convert hour angle to right ascension. [ (h is an hour angle in radians as a float) and (ut is a timestamp as a datetime.datetime instance) and (eLong is an east longitude in radians) -> return the right ascension in radians corresponding to that hour angle at that time and location ] """ This is Duffett-Smith's algorithm 24, “Converting between right ascension and hour-angle.” The formula relating hour-angle H and right ascension α is: The first step is to convert ut into Greenwich Sidereal Time, GST. See . #-- 1 -- # [ gst := the Greenwich Sidereal Time equivalent to # ut, as a SiderealTime instance ] gst = SiderealTime.fromDatetime ( ut ) Next we convert GST to LST, local sidereal time. See . #-- 2 -- # [ lst := the local time corresponding to gst at # longitude eLong ] lst = gst.lst ( eLong ) Finally we subtract H from LST, normalizing the result to [0,2π). #-- 3 -- # [ alpha := lst - h, normalized to [0,2*pi) ] alpha = (lst.radians - h) % TWO_PI #-- 4 -- return alpha
<code >raToHourAngle()</code >: Convert a right ascension to an hour angle This is the inverse of . The first two steps are the same: derive the GST and convert it to LST. # - - - r a T o H o u r A n g l e def raToHourAngle ( ra, ut, eLong ): """Convert right ascension to hour angle. [ (ra is a right ascension in radians as a float) and (ut is a timestamp as a datetime.datetime instance) and (eLong is an east longitude in radians) -> return the hour angle in radians at that time and location corresponding to that right ascension ] """ #-- 1 -- # [ gst := the Greenwich Sidereal Time equivalent to # ut, as a SiderealTime instance ] gst = SiderealTime.fromDatetime ( ut ) #-- 2 -- # [ lst := the local time corresponding to gst at # longitude eLong ] lst = gst.lst ( eLong ) All that remains is to subtract h from lst and normalize the result to [0,2π). #-- 3 -- # [ h := lst - ra, normalized to [0,2*pi) ] h = (lst.radians - ra) % TWO_PI #-- 4 -- return h
<code >dayNo()</code >: Date to day number This method returns the number of days between the given date dt, as either a datetime.date or datetime.datetime instance, and January 0 of that year. # - - - d a y N o def dayNo ( dt ): """Compute the day number within the year. [ dt is a date as a datetime.datetime or datetime.date -> return the number of days between dt and Dec. 31 of the preceding year ] """ This computation will use the Python datetime package's concept of the “proleptic Gregorian ordinal,” which is a day number based on January 1, 1AD. Both datetime.date and datetime.datetime instances have a .toordinal() method that returns this number. The datetime.date() constructor will not accept a date of January 0 (“ValueError: day is out of range for month”), so we'll subtract the ordinal of January 1, and then add 1. #-- 1 -- # [ dateOrd := proleptic Gregorian ordinal of dt # jan1Ord := proleptic Gregorian ordinal of January 1 # of year (dt.year) ] dateOrd = dt.toordinal() jan1Ord = datetime.date ( dt.year, 1, 1 ).toordinal() #-- 2 -- return dateOrd - jan1Ord + 1
<code >parseDatetime()</code >: Convert an external date-time string A date-time string consists of a date string, optionally followed by letter “T” (case-insensitive) and a time string. T_PATTERN is a regular expression that matches either case of “T”. # - - - p a r s e D a t e t i m e T_PATTERN = re.compile ( '[tT]' ) def parseDatetime ( s ): """Parse a date with optional time. [ s is a string -> if s is a valid date with optional time -> return that timestamp as a datetime.datetime instance else -> raise SyntaxError ] """ In general, date-time expressions can be quite complex. Using Python's re package, we might write a regular expression to match all the cases, but it would be huge. Just for conceptual clarity, we'll break into two sub-problems: we'll use to process the date, and we'll use to process the time if there is one. If s does not contain letter “T” or “t”, then it must represent just a date; use parseDate() to convert it. If there is a “T”, break the string in two at that point, send the pieces to parseDate() and parseTime(), and reassemble them. The .search() method on a compiled regular expression finds the first occurrence of a pattern anywhere in its argument; the returned match object has methods .start() and .end() that delineate where the match occurred. #-- 1 -- # [ if s contains "T" or "t" -> # rawDate := s up to the first such character # rawTime := s from just after the first such # character to the end # else -> # rawDate := s # rawTime := None ] m = T_PATTERN.search ( s ) if m is None: rawDate, rawTime = s, None else: rawDate = s[:m.start()] rawTime = s[m.end():] The parseDate() function will handle checking and conversion of the date part. #-- 2 -- # [ if rawDate is a valid date -> # datePart := rawDate as a datetime.datetime instance # else -> raise SyntaxError ] datePart = parseDate ( rawDate ) If rawTime is not None, we call to validate and convert it, and store the result in timePart. If rawTime is None, there is no time, so we'll set timePart to a datetime.time instance representing 00:00. #-- 3 -- # [ if rawTime is None -> # timePart := 00:00 as a datetime.time # else if rawTime is valid -> # timePart := rawTime as a datetime.time # else -> raise SyntaxError ] if rawTime is None: timePart = datetime.time ( 0, 0 ) else: timePart = parseTime ( rawTime ) The static .combine() method of class datetime.datetime takes a datetime.date and a datetime.time and combines them to produce a datetime.datetime instance. #-- 4 -- return datetime.datetime.combine ( datePart, timePart )
<code >parseDate()</code >: Convert an external date string This function checks a string s to see if it is a valid date string as described in the specification. Although the ISO standard requires left zeroes on all three units, we'll be a little lax about the month and year. However, to prevent a repetition of that ugly Y2K business, we'll absolutely require four digits for the year. The compiled regular expression DATE_PAT implements these rules. YEAR_FIELD, MONTH_FIELD, and DAY_FIELD are the group names used to retrieve the values of the year, month, and day once the pattern has matched. # - - - p a r s e D a t e YEAR_FIELD = "Y" MONTH_FIELD = "M" DAY_FIELD = "D" dateRe = ( r'(' # Begin YEAR_FIELD r'?P<%s>' # Name this group YEAR_FIELD r'\d{4}' # Match exactly four digits r')' # End YEAR_FIELD r'\-' # Matches one hyphen r'(' # Begin MONTH_FIELD r'?P<%s>' # Name this group MONTH_FIELD r'\d{1,2}' # Matches one or two digits r')' # End MONTH_FIELD r'\-' # Matches "-" r'(' # Begin DAY_FIELD r'?P<%s>' # Name this group DAY_FIELD r'\d{1,2}' # Matches one or two digits r')' # End DAY_FIELD r'$' # Make sure all characters match ) % (YEAR_FIELD, MONTH_FIELD, DAY_FIELD) DATE_PAT = re.compile ( dateRe ) def parseDate ( s ): """Validate and convert a date in external form. [ s is a string -> if s is a valid external date string -> return that date as a datetime.date instance else -> raise SyntaxError ] """ If DATE_PAT matches s, we'll get back a match instance; otherwise we get back None. #-- 1 -- # [ if DATE_PAT matches s -> # m := a match instance describing the match # else -> raise SyntaxError ] m = DATE_PAT.match ( s ) if m is None: raise SyntaxError, ( "Date does not have pattern YYYY-DD-MM: " "'%s'" % s ) We retrieve the contents of the three fields using the match instance's .group() method, then construct and return a datetime.date instance. #-- 2 -- year = int ( m.group ( YEAR_FIELD ) ) month = int ( m.group ( MONTH_FIELD ) ) day = int ( m.group ( DAY_FIELD ) ) #-- 3 -- return datetime.date ( year, month, day )
<code >parseTime()</code >: Convert an external time string This function validates and converts an external time of day s, with optional time zone modifier, as described in . Rather than try to do all the parsing and breaking out of pieces with one big regular expression, we'll use a mixed strategy that goes roughly like this: The string s must start with one or more digits, optionally followed by a decimal point and more digits. Remove this and save it as a float in decHour. If what is left starts with “:”, remove that, followed by another float number, and save as as decMinute. Similarly, if what follows that is another “:”, remove the second colon and save the number that must follow in decSecond. If there is still something left, it must be a time zone modifier. Call to validate and convert that to an instance of a class that inherits from datetime.tzinfo. If there is anything left at this point, it is an error. # - - - p a r s e T i m e def parseTime ( s ): """Validate and convert a time and optional zone. [ s is a string -> if s is a valid time with optional zone suffix -> return that time as a datetime.time else -> raise SyntaxError ] """ The first order of business is to remove the time from the front of the string. We use to match each floating-point number. #-- 1 - # [ if s starts with FLOAT_PAT -> # decHour := matching part of s as a float # minuteTail := part s past the match # else -> raise SyntaxError ] decHour, minuteTail = parseFloat ( s, "Hour number" ) If minuteTail starts with a colon, remove the minutes. #-- 2 -- # [ if minuteTail starts with ":" followed by FLOAT_PAT -> # decMinute := part matching FLOAT_PAT as a float # secondTail := part of minuteTail after the match # else if minuteTail starts with ":" not followed by # FLOAT_PAT -> # raise SyntaxError # else -> # decMinute := 0.0 # secondTail := minuteTail ] if minuteTail.startswith(':'): m = FLOAT_PAT.match ( minuteTail[1:] ) if m is None: raise SyntaxError, ( "Expecting minutes: '%s'" % minuteTail ) else: decMinute = float(m.group()) secondTail = minuteTail[m.end()+1:] else: decMinute = 0.0 secondTail = minuteTail If secondTail starts with a colon, remove the seconds. #-- 3 -- # [ if secondTail starts with ":" followed by FLOAT_PAT -> # decSecond := part matching FLOAT_PAT as a float # zoneTail := part of secondTail after the match # else if secondTail starts with ":" not followed by # FLOAT_PAT -> # raise SyntaxError # else -> # decSecond := 0.0 # zoneTail := secondTail ] if secondTail.startswith(':'): m = FLOAT_PAT.match ( secondTail[1:] ) if m is None: raise SyntaxError, ( "Expecting seconds: '%s'" % secondTail ) else: decSecond = float(m.group()) zoneTail = secondTail[m.end()+1:] else: decSecond = 0.0 zoneTail = secondTail If anything is left, it had better be a zone. #-- 4 -- # [ if zoneTail is empty -> # tz := None # else if zoneTail is a valid zone suffix -> # tz := that zone information as an instance of a class # that inherits from datetime.tzinfo # else -> raise SyntaxError ] if len(zoneTail) == 0: tz = None else: tz = parseZone ( zoneTail ) All that remains is to assemble the parts. At this point we have three numbers for hours, minutes, and seconds, any of which may not be integral. In order to conform to the way the datetime module likes to see times, we'll convert that to decimal hours, then back to mixed units, using . #-- 5 -- # [ hours := decHour + decMinute/60.0 + decSecond/3600.0 ] hours = dmsUnits.mixToSingle ( (decHour, decMinute, decSecond) ) The datetime.time() constructor wants integer hours, minutes, seconds, and microseconds. The dmsUnits.singleToMix() method returns integer hours, integer minutes, and floating seconds; we'll do the remaining two conversions explicitly. #-- 6 -- # [ return a datetime.time representing hours ] hh, mm, seconds = dmsUnits.singleToMix ( hours ) wholeSeconds, fracSeconds = divmod ( seconds, 1.0 ) ss = int(wholeSeconds) usec = int ( fracSeconds * 1e6 ) return datetime.time ( hh, mm, ss, usec, tz )
<code >parseZone()</code >: Process a time zone suffix For the various forms allowed as time zone suffixes, refer to the specification. # - - - p a r s e Z o n e def parseZone ( s ): """Validate and convert a time zone suffix. [ s is a string -> if s is a valid time zone suffix -> return that zone's information as an instance of a class that inherits from datetime.tzinfo else -> raise SyntaxError ] """ The only supported zone suffixes with variable content are the “+hhmm” and “-hhmm” forms. The rest can be handled with a dictionary whose keys are the various time zone codes (uppercased, so we can be case-insensitive), and each corresponding value is the appropriate tzinfo instance. For this dictionary, see . #-- 1 -- # [ if s starts with "+" or "-" and is a valid fixed-offset # time zone suffix -> # return that zone's information as a datetime.tzinfo instance # else if is starts with "+" or "-" but is not a valid # fixed-offset time zone suffix -> # raise SyntaxError # else -> I ] if s.startswith("+") or s.startswith("-"): return parseFixedZone ( s ) #-- 2 -- # [ if s.upper() is a key in zoneCodeMap -> # return the corresponding value # else -> raise SyntaxError ] try: tz = zoneCodeMap[s.upper()] return tz except KeyError: raise SyntaxError, ( "Unknown time zone code: '%s'" % s )
<code >parseFixedZone()</code >: Parse fixed zone suffix If the argument s is a fixed time zone offset of the form “±hhmm”, this function returns an instance of class FixedZone representing that offset. # - - - p a r s e F i x e d Z o n e HHMM_PAT = re.compile ( r'\d{4}' # Matches exactly four digits r'$' ) # Be sure everything is matched def parseFixedZone ( s ): """Convert a +hhmm or -hhmm zone suffix. [ s is a string -> if s is a time zone suffix of the form "+hhmm" or "-hhmm" -> return that zone information as an instance of a class that inherits from datetime.tzinfo else -> raise SyntaxError ] """ The first character must be “+” or “-”; we set sign to +1 or -1, respectively. #-- 1 -- if s.startswith('+'): sign = 1 elif s.startswith('-'): sign = -1 else: raise SyntaxError, ( "Expecting zone modifier as %shhmm: " "'%s'" % (s[0], s) ) Use a regular expression to check the length and content of the hours and minutes. Then return an instance of the FixedZone class representing that number of hours and minutes. #-- 2 -- # [ if s[1:] matches HHMM_PAT -> # hours := the HH part as an int # minutes := the MM part as an int # else -> raise SyntaxError ] rawHHMM = s[1:] m = HHMM_PAT.match ( rawHHMM ) if m is None: raise SyntaxError, ( "Expecting zone modifier as %sHHMM: " "'%s'" % (s[0], s) ) else: hours = int ( rawHHMM[:2] ) minutes = int ( rawHHMM[2:] ) #-- 3 -- return FixedZone ( sign*hours, sign*minutes, s )
<code >class FixedZone</code >: Fixed-offset time zone This class represents a time zone with a fixed offset in hours and minutes east of UTC. It is a concrete class implementing the abstract class datetime.tzinfo, so it must implement concrete methods utcoffset(), tzname(), and dst(). # - - - - - c l a s s F i x e d Z o n e DELTA_ZERO = datetime.timedelta(0) DELTA_HOUR = datetime.timedelta(hours=1) class FixedZone(datetime.tzinfo): """Represents a time zone with a fixed offset east of UTC. Exports: FixedZone ( hours, minutes, name ): [ (hours is a signed offset in hours as an int) and (minutes is a signed offset in minutes as an int) -> return a new FixedZone instance representing those offsets east of UTC ] State/Invariants: .__offset: [ a datetime.timedelta representing self's offset east of UTC ] .__name: [ as passed to the constructor's name argument ] """ This class is an adaptation of the FixedOffset class shown in the examples section of the reference material for datetime.tzinfo. The constructor combines the hours and minutes arguments into a datetime.timedelta instance and stores them in the instance. def __init__ ( self, hh, mm, name ): """Constructor for FixedZone. """ self.__offset = datetime.timedelta ( hours=hh, minutes=mm ) self.__name = name The .utcoffset() method returns the offset east of UTC. def utcoffset(self, dt): """Return self's offset east of UTC. """ return self.__offset The .tzname() method returns the zone's name. def tzname(self, dt): """Return self's name. """ return self.__name The .dst() method always returns DELTA_ZERO, since a fixed time zone by definition never has daylight time. def dst(self, dt): """Return self's daylight time offset. """ return DELTA_ZERO
<code >class USTimeZone</code >: Time zone with daylight time This class implements the daylight saving time rules for the USA, honoring the change that went into effect in 2007. Dates before 2007 are assumed to use the old rules. Daylight time always changes on a Sunday. To compute the dates of those Sundays in a particular year, we will need the following function. Given a datetime.date instance dt, it computes the date of the first Sunday on or after that date, and returns the result as a datetime.date. def firstSundayOnOrAfter ( dt ): """Find the first Sunday on or after a given date. [ dt is a datetime.date -> return a datetime.date representing the first Sunday on or after dt ] """ Because the .weekday() method returns a number that represents Sunday as 6, we subtract that number from 6 to get the number of days between dt and the next Sunday. Then we use a datetime.timedelta instance to add to dt to yield the Sunday date. daysToGo = dt.weekday() if daysToGo: dt += datetime.timedelta ( daysToGo ) return dt Here's the class itself. # - - - - - c l a s s U S T i m e Z o n e class USTimeZone(datetime.tzinfo): """Represents a U.S. time zone, with automatic daylight time. Exports: USTimeZone ( hh, mm, name, stdName, dstName ): [ (hh is an offset east of UTC in hours) and (mm is an offset east of UTC in minutes) and (name is the composite zone name) and (stdName is the non-DST name) and (dstName is the DST name) -> return a new USTimeZone instance with those values ] State/Invariants: .__offset: [ self's offset east of UTC as a datetime.timedelta ] .__name: [ as passed to constructor's name ] .__stdName: [ as passed to constructor's stdName ] .__dstName: [ as passed to constructor's dstName ] """ This class is an adaptation of the USTimeZone class shown in the examples section of the reference material for datetime.tzinfo, with modifications for the new daylight time rules. We'll need class variables for the calculation of the DST changeover dates. In each case, we want a date such that we can plug in the given year and send it to the firstSundayOnOrAfter() function above to yield a DST changeover date. DST_START_OLD: The pre-2007 rule for DST is that it starts on the first Sunday in April, at 2am. Hence, this date is April 1. Applying firstSundayOnOrAfter() to this date gives us the first Sunday in April at 2am. DST_START_OLD = datetime.datetime ( 1, 4, 1, 2 ) DST_END_OLD: The pre-2007 rule is that DST ends on the last Sunday of October, that is, the first Sunday on or after October 25. DST_END_OLD = datetime.datetime ( 1, 10, 25, 2 ) DST_START_2007: The new rule is that DST starts on the second Sunday in March, that is, the first Sunday on or after March 8. DST_START_2007 = datetime.datetime ( 1, 3, 8, 2 ) DST_END_2007: Since 2007, DST ends on the first Sunday in November. DST_END_2007 = datetime.datetime ( 1, 11, 1, 2 ) Here's the class constructor. def __init__ ( self, hh, mm, name, stdName, dstName ): self.__offset = datetime.timedelta ( hours=hh, minutes=mm ) self.__name = name self.__stdName = stdName self.__dstname = dstName The .tzname() method returns the current name, which depends on whether the given time is DST or not. def tzname(self, dt): if self.dst(dt): return self.__dstName else: return self.__stdName The .utcoffset() method returns the offset east of UTC, taking into account whether DST is in effect. We use the fact that a datetime.timedelta with a zero offset is treated as false in Boolean contexts. def utcoffset(self, dt): return self.__offset + self.dst(dt) The .dst() method returns an offset as a datetime.timedelta, and determines whether DST is in effect. def dst(self, dt): """Return the current DST offset. [ dt is a datetime.date -> if daylight time is in effect in self's zone on date dt -> return +1 hour as a datetime.timedelta else -> return 0 as a datetime.delta ] """ This implementation will ignore the .tzinfo attribute of the dt argument, and just use self's zone information. First we must find the starting and ending Sundays for DST for the year given by dt. The .replace() method gives us a new datetime instance with the year taken from dt. #-- 1 -- # [ dtStart := Sunday when DST starts in year dt.year # dtEnd := Sunday when DST ends in year dt.year ] if dt.year >= 2007: startDate = self.DST_START_2007.replace ( year=dt.year ) endDate = self.DST_END_2007.replace ( year=dt.year ) else: startDate = self.DST_START_OLD.replace ( year=dt.year ) endDate = self.DST_END_OLD.replace ( year=dt.year ) dtStart = firstSundayOnOrAfter ( startDate ) dtEnd = firstSundayOnOrAfter ( endDate ) The datetime module does not allow naive times to be compared to aware times, so we'll make a copy of dt with its time zone information removed. #-- 2 -- # [ naiveDate := dt with its tzinfo member set to None ] naiveDate = dt.replace ( tzinfo=None ) Now we can find out if naiveDate is within the DST range, and return the appropriate offset. #-- 3 -- # [ if naiveDate is in the interval (dtStart, dtEnd) -> # return DELTA_HOUR # else -> # return DELTA_ZERO ] if dtStart <= naiveDate < dtEnd: return DELTA_HOUR else: return DELTA_ZERO
<code >zoneCodeMap</code >: Dictionary of time zones This dictionary is used in to convert time zone codes to tzinfo instances. utcZone = FixedZone(0, 0, "UTC") estZone = FixedZone(-5, 0, "EST") edtZone = FixedZone(-4, 0, "EDT") etZone = USTimeZone(-5, 0, "ET", "EST", "EDT") cstZone = FixedZone(-6, 0, "CST") cdtZone = FixedZone(-5, 0, "CDT") ctZone = USTimeZone(-6, 0, "CT", "CST", "CDT") mstZone = FixedZone(-7, 0, "MST") mdtZone = FixedZone(-6, 0, "MDT") mtZone = USTimeZone(-7, 0, "MT", "MST", "MDT") pstZone = FixedZone(-8, 0, "PST") pdtZone = FixedZone(-7, 0, "PDT") ptZone = USTimeZone(-8, 0, "PT", "PST", "PDT") zoneCodeMap = { "UTC": utcZone, "EST": estZone, "EDT": edtZone, "ET": etZone, "CST": cstZone, "CDT": cdtZone, "CT": ctZone, "MST": mstZone, "MDT": mdtZone, "MT": mtZone, "PST": pstZone, "PDT": pdtZone, "PT": ptZone }
<code >parseAngle()</code >: Convert an external angle string This function validates and converts a string containing an angle in mixed units, such as “34d18.37m” or “34d18m4.006s”. The degrees part is required; the minutes and seconds are optional. # - - - p a r s e A n g l e def parseAngle ( s ): """Validate and convert an external angle. [ s is a string -> if s is a valid external angle -> return s in radians else -> raise SyntaxError ] """ The general approach is first to require the degrees part—a floating-point number—followed by “d” (either case). If there is anything after that, it must start with another float and letter “m”. If there is still more, it must be another float and “s”, and nothing more. First we set up default values for the optional minutes and seconds. Then we process the degrees and its suffix. #-- 1 -- minute = second = 0.0 #-- 2 -- # [ if s starts with a float followed by 'd' or 'D' -> # degree := that float as type float # minTail := s after that float and suffix # else -> raise SyntaxError ] degree, minTail = parseFloatSuffix ( s, D_PAT, "Degrees followed by 'd'" ) #-- 3 -- # [ if minTail is empty -> I # else if minTail has the form "(float)m" -> # minute := that (float) # else if minTail has the form "(float)m(float)s" -> # minute := the first (float) # second := the second (float) # else -> raise SyntaxError ] if len(minTail) != 0: #-- 3.1 -- # [ if minTail starts with a float followed by 'm' or 'M' -> # minute := that float as type float # secTail := minTail after all that # else -> raise SyntaxError ] minute, secTail = parseFloatSuffix ( minTail, M_PAT, "Minutes followed by 'm'" ) #-- 3.2 -- # [ if secTail is empty -> I # else if secTail starts with a float followed by # 's' or 'S' -> # second := that float as type float # checkTail := secTail after all that # else -> raise SyntaxError ] if len(secTail) != 0: second, checkTail = parseFloatSuffix ( secTail, S_PAT, "Seconds followed by 's'" ) if len(checkTail) != 0: raise SyntaxError, ( "Unidentifiable angle parts: " "'%s'" % checkTail ) To convert from mixed units, we use . #-- 4 -- # [ return the angle (degree, minute, second) in radians ] angleDegrees = dmsUnits.mixToSingle ( (degree, minute, second) ) return radians ( angleDegrees )
<code >parseFloatSuffix</code >: Parse a number followed by a code This utility routine is used to handle the common case where a floating-point number must be followed by a specific letter, such as in the angle expression “107m”. # - - - p a r s e F l o a t S u f f i x def parseFloatSuffix ( s, codeRe, message ): """Parse a float followed by a letter code. [ (s is a string) and (codeRe is a compiled regular expression) and (message is a string describing what is expected) -> if s starts with a float, followed by code (using case-insensitive comparison) -> return (x, tail) where x is that float as type float and tail is the part of s after the float and code else -> raise SyntaxError, "Expecting (message)" ] """ We use to remove the required floating number from the front of s. We could just pass through the SyntaxError exception that that routine will raise, but we catch and re-raise it here so as to provide more information about what is expected. #-- 1 -- # [ if s starts with a float -> # x := that float as type float # codeTail := the part of s after that float # else -> raise SyntaxError, "Expecting (message)" ] x, codeTail = parseFloat ( s, message ) #-- 2 -- # [ if codeTail starts with code (case-insensitive) -> # return (x, the part of codeTail after the match) # else -> raise SyntaxError ] discard, tail = parseRe ( codeTail, codeRe, message ) #-- 3 -- return (x, tail)
<code >parseFloat()</code >: Parse a floating-point number A service routine, this function removes a floating-point number from the head of s. # - - - p a r s e F l o a t def parseFloat ( s, message ): """Parse a floating-point number at the front of s. [ (s is a string) and (message is a string describing what is expected) -> if s begins with a floating-point number -> return (x, tail) where x is the number as type float and tail is the part of s after the match else -> raise SyntaxError, "Expecting (message)" ] """ We use the precompiled regular expression from to match the number. #-- 1 -- # [ if the front of s matches FLOAT_PAT -> # m := a Match object describing the match # else -> raise SyntaxError ] rawFloat, tail = parseRe ( s, FLOAT_PAT, message ) The matching string is available as m.group(). The position just after the match is available as m.end(). #-- 2 -- return (float(rawFloat), tail)
<code >parseRe()</code >: Parse a regular expression A service routine used anywhere you want to match a regular expression at the start of a string. # - - - p a r s e R e def parseRe ( s, regex, message ): """Parse a regular expression at the head of a string. [ (s is a string) and (regex is a compiled regular expression) and (message is a string describing what is expected) -> if s starts with a string that matches regex -> return (head, tail) where head is the part of s that matched and tail is the rest else -> raise SyntaxError, "Expecting (message)" ] """ #-- 1 -- # [ if the head of s matches regex -> # m := a match object describing the matching part # else -> raise SyntaxError, "Expecting (message)" ] m = regex.match ( s ) if m is None: raise SyntaxError, "Expecting %s: '%s'" % (message, s) The match instance m has a method .group() that returns the matched text. The m.end() method returns the position just past the matched text. #-- 2 -- # [ return (matched text from s, text from s after match) ] head = m.group() tail = s[m.end():] return (head, tail)
<code >parseLat()</code >: Convert an external latitude # - - - p a r s e L a t def parseLat ( s ): """Validate and convert an external latitude. [ s is a nonempty string -> if s is a valid external latitude -> return that latitude in radians else -> raise SyntaxError ] """ A latitude has two pieces: an angle, and a suffix letter which must be either “n” or “s”, case-insensitive. First we'll peel off the suffix and check it using . #-- 1 -- # [ last := last character of s # rawAngle := s up to the last character ] last = s[-1] rawAngle = s[:-1] #-- 2 -- # [ if last matches NS_PAT -> # nsFlag := last, lowercased # else -> raise SyntaxError ] m = NS_PAT.match ( last ) if m is None: raise SyntaxError, ( "Latitude '%s' does not end with 'n' " "or 's'." % s ) else: nsFlag = last.lower() Validating the angle part is done by . #-- 3 -- # [ if rawAngle is a valid angle -> # absAngle := that angle in radians # else -> raise SyntaxError ] absAngle = parseAngle ( rawAngle ) North latitude is positive, and south latitude is negative. #-- 4 -- if nsFlag == 's': angle = - absAngle else: angle = absAngle #-- 5 -- return angle
<code >parseLon()</code >: Convert an external longitude # - - - p a r s e L o n def parseLon ( s ): """Validate and convert an external longitude. [ s is a nonempty string -> if s is a valid external longitude -> return that longitude in radians else -> raise SyntaxError ] """ First we'll use to validate the suffix letter specifying east or west longitude. #-- 1 -- # [ last := last character of s # rawAngle := s up to the last character ] last = s[-1] rawAngle = s[:-1] #-- 2 -- # [ if EW_PAT matches last -> # ewFlag := last, lowercased # else -> raise SyntaxError ] m = EW_PAT.match ( last ) if m is None: raise SyntaxError, ( "Longitude '%s' does not end with " "'e' or 'w'." % s ) else: ewFlag = last.lower() Next, check the angle with . #-- 3 -- # [ if rawAngle is a valid angle -> # absAngle := that angle in radians # else -> raise SyntaxError ] absAngle = parseAngle ( rawAngle ) All that remains is to attach the sign. West Longitude is converted to East Longitude by subtracting from 2π. #-- 4 -- if ewFlag == 'w': angle = TWO_PI - absAngle else: angle = absAngle #-- 5 -- return angle
<code >parseHours()</code >: Convert an external quantity in hours # - - - p a r s e H o u r s def parseHours ( s ): """Validate and convert a quantity in hours. [ s is a non-empty string -> if s is a valid mixed hours expression -> return the value of s as decimal hours else -> raise SyntaxError ] """ First we'll set the optional minute and second to their default values of zero. The only required part is a floating hours followed by “h” (case-insensitive). We'll use to process both the float and the suffix letter. The process is repeated for the minutes and seconds if present. #-- 1 -- minute = second = 0.0 #-- 2 -- # [ if s starts with a float followed by 'h' or 'H' -> # hour := that float as type float # minTail := s after that float and suffix # else -> raise SyntaxError ] hour, minTail = parseFloatSuffix ( s, H_PAT, "Hours followed by 'h'" ) #-- 3 -- # [ if minTail is empty -> I # else if minTail has the form "(float)m" -> # minute := that (float) # else if minTail has the form "(float)m(float)s" -> # minute := the first (float) # second := the second (float) # else -> raise SyntaxError ] if len(minTail) != 0: #-- 3.1 -- # [ if minTail starts with a float followed by 'm' or 'M' -> # minute := that float as type float # secTail := minTail after all that # else -> raise SyntaxError ] minute, secTail = parseFloatSuffix ( minTail, M_PAT, "Minutes followed by 'm'" ) #-- 3.2 -- # [ if secTail is empty -> I # else if secTail starts with a float followed by # 's' or 'S' -> # second := that float as type float # checkTail := secTail after all that # else -> raise SyntaxError ] if len(secTail) != 0: second, checkTail = parseFloatSuffix ( secTail, S_PAT, "Seconds followed by 's'" ) if len(checkTail) != 0: raise SyntaxError, ( "Unidentifiable angle parts: " "'%s'" % checkTail ) To convert from mixed units, we use . #-- 4 -- # [ return the quantity (hour, minute, second) in hours ] result = dmsUnits.mixToSingle ( (hour, minute, second) ) return result
<code >class MixedUnits</code >: Operations on mixed-unit systems # - - - - - c l a s s M i x e d U n i t s class MixedUnits: """Represents a system with mixed units, e.g., hours/minutes/seconds """
<code >MixedUnits.__init__()</code >: Constructor The constructor has little to do except store its argument in the instance. # - - - M i x e d U n i t s . _ _ i n i t _ _ def __init__ ( self, factors ): """Constructor """ self.factors = factors
<code >MixedUnits.mixToSingle()</code >: Convert to a single value This method converts a value in mixed units to a single value in the largest unit. # - - - M i x e d U n i t s . m i x T o S i n g l e def mixToSingle ( self, coeffs ): """Convert mixed units to a single value. [ coeffs is a sequence of numbers not longer than len(self.factors)+1 -> return the equivalent single value in self's system ] """ First let's work out the math. Consider the days-hours-minutes-seconds system: the factor list is (24, 60, 60). So there are 24 hours in a day; 24×60 or 1440 minutes in a day; and 24×60×60 or 86,400 seconds in a day. The formula we use for conversion depends on how many elements are in the coeffs sequence. If there is only one value, it is treated as days. Two values are treated as days and hours; three values are treated as days, hours, and minutes; and so on. Here are the equations for converting coeffs values of one, two, three, and four elements, respectively: For example, the expression for reducing 38° 52′ 30.7″ to decimal degrees is ((30.7/60)+52)/60+38 or about 38.875194 degrees. Note the way we rewrite the expressions to form a sequence of alternating divide and add operations, starting with the smallest units and working toward the largest. This suggests the form of the evaluation loop: we will work through the factor list from right to left, adding to the total a value from coeffs, and then dividing the total by the corresponding factor in turn. Finally we add the first element of coeffs, unweighted. In order to simplify the logic that matches elements of coeffs to their corresponding elements of the factor list, if coeffs is shorter than the maximum length, we'll make a copy of coeffs with zero elements added on the right if necessary to pad it to the standard length. See , which may raise ValueError if there are too many elements. #-- 1 -- total = 0.0 #-- 2 -- # [ if len(coeffs) <= len(self.factors)+1 -> # coeffList := a copy of coeffs, right-padded to length # len(self.factors)+1 with zeroes if necessary ] coeffList = self.__pad ( coeffs ) At this point, we use Python's negative indexing convention to work through the coefficients from right to left, adding each coefficient, then dividing by the factor list element at the same position. The range() expression here generates the sequence [-1, -2, …, -len(self.factors)]. #-- 3 -- # [ total +:= (coeffList[-1] * # (product of all elements of self.factors)) + # (coeffList[-2] * # (product of all elements of self.factors[:-1])) + # (coeffList[-3] * # (product of all elements of self.factors[:-2])) # ... ] for i in range ( -1, -len(self.factors)-1, -1): total += coeffList[i] total /= self.factors[i] That takes care of all elements of coeffList but the first; we add that one in, unweighted. #-- 4 -- total += coeffList[0] #-- 5 -- return total
<code >MixedUnits.__pad()</code >: Pad short coefficient lists to standard length This utility method is used to make a copy of a coefficient list, and add zeroes on the right if necessary to pad it out to the standard length, which is len(self.factors)+1. # - - - M i x e d U n i t s . _ _ p a d def __pad ( self, coeffs ): """Pad coefficient lists to standard length. [ coeffs is a sequence of numbers -> if len(coeffs) > len(self.factors)+1 -> raise ValueError else -> return a list containing the elements of coeff, plus additional zeroes on the right if necessary so that the result has length len(self.factors)+1 ] """ First we set stdLen to the standard length, then set shortage to the number of elements we have to add to coeffs to reach that length. If shortage is negative, that's an error: coeffs is too long for this system. We use the fact that Python's list() function makes a copy of its argument, even if the argument is a list. If the argument is a tuple, it is converted to a list. #-- 1 -- # [ stdLen := 1 + len(self.factors) # shortage := 1 + len(self.factors) - len(coeffs) # result := a copy of coeffs as a list ] stdLen = 1 + len(self.factors) shortage = stdLen - len(coeffs) result = list(coeffs) #-- 2 -- # [ if shortage < 0 -> # raise ValueError # else -> # result := result + (a list of shortage zeroes) ] if shortage < 0: raise ValueError, ( "Value %s has too many elements; " "max is %d." % (coeffs, stdLen) ) elif shortage > 0: result += [0.0] * shortage #-- 3 -- return result
<code >MixedUnits.singleToMix()</code >: Convert to mixed units This method takes a single quantity, in the largest unit of the system, and converts it to mixed units. # - - - M i x e d U n i t s . s i n g l e T o M i x def singleToMix ( self, value ): """Convert to mixed units. [ value is a float -> return value as a sequence of coefficients in self's system ] """ The first element of the result list is the whole part of the value. #-- 1 -- # [ whole := whole part of value # frac := fractional part of value ] whole, frac = divmod ( value, 1.0 ) result = [int(whole)] For each factor in the system, we then multiply the fraction from the previous step by that factor, and separate the result into whole and fractional parts. #-- 2 -- # [ result := result with integral parts of value # in self's system appended ] for factorx in range(len(self.factors)): frac *= self.factors[factorx] whole, frac = divmod ( frac, 1.0 ) result.append ( int(whole) ) After the loop above, frac contains the fractional part of the value in the smallest unit, so we must add it to the last element of the result. #-- 3 -- # [ result := result with frac added to its last element ] result[-1] += frac #-- 4 -- return result
<code >MixedUnits.format()</code >: Format mixed units This method takes a mixed-units value as a sequence of numbers, and returns a list of strings containing those numbers formatted in the way described in the specification. # - - - M i x e d U n i t s . f o r m a t def format ( self, coeffs, decimals=0, lz=False ): """Format mixed units. [ (coeffs is a sequence of numbers as returned by MixedUnits.singleToMix()) and (decimals is a nonnegative integer) and (lz is a bool) -> return a list of strings corresponding to the values of coeffs, with all the values but the last formatted as integers, all values zero padded iff lz is true, and the last value with (decimals) digits after the decimal point ] """ The important feature of this method is to prevent ever returning a last string which is greater than equal to self.factors[-1]. For example, in the degrees-minutes-seconds system, if the seconds value is 59.9999, we want to avoid ever showing a value of "60", "60.0", or anything like that. We'll implement this constraint by truncating any extra digits, so 59.999 will display as "59", "59.9", "59.99", and so forth for the various values of decimals. For the decimals=0 case, if the fractional part of the last value is 0.5 or greater, formatting with "%.0f" will round the value undesirably; in that case, we subtract 0.5 from the last value to effectively truncate instead of rounding. For decimals=1, if the fractional part is 0.95 or greater, formatting with "%.1f" will round. In that case, we subtract 0.05 from the last value. Progressing toward a general case, here is a table showing the first few values of decimals, the range of fraction values that will cause rounding, and the fudge factor to be subtracted from the last value to prevent rounding. decimals Rounding occurs Fudge factor 0 >= 0.5 0.5 1 >= 0.95 0.05 2 >= 0.995 0.005 3 >= 0.9995 0.0005 Generalizing, whenever the fractional part of the last value in the coeffs sequence is greater than or equal to 1-0.5×10-decimals, we must subtract 0.5×10-decimals from the last value. First, we set coeffList to a copy of coeffs, right-padded with zero elements to standard length. Then we use a list comprehension to format all the values but the last as integers. #-- 1 -- coeffList = self.__pad ( coeffs ) #-- 2 -- # [ result := the values from coeffList[:-1] formatted # as integers ] if lz: fmt = "%02d" else: fmt = "%d" result = [ fmt % x for x in coeffList[:-1] ] Next we separate the last value into whole and fractional parts, and set fuzz to the quantity 0.5×10-decimals. #-- 2 -- # [ whole := whole part of coeffList[-1] # frac := fractional part of coeffList[-1] # fuzz := 0.5 * (10 ** (-decimals) ] whole, frac = divmod ( float(coeffList[-1]), 1.0 ) fuzz = 0.5 * (10.0 ** (-decimals)) Now apply the test and adjust if necessary. #-- 3 -- # [ if frac >= (1-fuzz) -> # result +:= [whole+frac-fuzz], formatted with # (decimals) digits after the decimal # else -> # result += coeffList[-1], formatted with (decimals) # digits after the decimal ] if frac >= (1.0-fuzz): corrected = whole + frac - fuzz else: corrected = coeffList[-1] Next, the formatting. There are three cases. If there are no left zeroes, we just use a format of the form "%.Df", where D is decimals. If the caller wants left zeroes, the format has the form "%0N.Df", where N is decimals plus three—two for the digits to the left of the decimal, and one for the decimal. For left zeroes in the case of decimals=0, the format code is "%0N.Df", but in that case N is one less, because there will be no decimal point. #-- 4 -- # [ if lz -> # s := corrected, formatted with 2 digits of left-zero # padding and (decimals) precision # else -> # s := corrected, formatted with (decimals) precision ] if lz: if decimals: n = decimals+3 else: n = decimals+2 s = "%0*.*f" % (n, decimals, corrected) else: s = "%.*f" % (decimals, corrected) #-- 5 -- result.append ( s ) #-- 6 -- return result
<code >dmsUnits</code >: Mixed-units converter This instance of MixedUnits is used to convert to and from mixed units in either the hours-minutes-seconds system or the degrees-minutes-seconds system. Both systems have the same factor list: (60, 60). dmsUnits = MixedUnits ( (60, 60) )
<code >class LatLon</code >: Observer latitude and longitude An instance of this class represents a position on the earth's surface as a latitude (signed, positive for north of the equator) and a longitude (east from longitude 0°). # - - - - - c l a s s L a t L o n class LatLon: """Represents a latitude+longitude. """
<code >LatLon.__init__()</code >: Constructor The constructor takes the values directly in radians, and stores them that way. The longitude is normalized to the interval [0, 2π). # - - - L a t L o n . _ _ i n i t _ _ def __init__ ( self, lat, lon ): """Constructor for LatLon. """ self.lat = lat self.lon = lon % TWO_PI
<code >LatLon.__str__()</code >: Convert to a string # - - - L a t L o n . _ _ s t r _ _ def __str__ ( self ): """Return self as a string. """ Values returned here should look like this example: [03d 14m 32s N Lat 118d 32m 04s W Lon] Because self.lon is in the range [0, 2π], we have to treat values in the range [π, 2π) differently: values in that range are subtracted from 2π, and those will be shown as west longitude. Similarly, negative latitudes are shown as positive south latitude. The degrees() function from Python's math module converts radians to degrees. #-- 1 -- if self.lon >= pi: e_w = "W" lonDeg = degrees ( TWO_PI - self.lon ) else: e_w = "E" lonDeg = degrees ( self.lon ) #-- 2 -- if self.lat < 0: n_s = "S" latDeg = degrees ( - self.lat ) else: n_s = "N" latDeg = degrees ( self.lat ) Next we get lists of formatted values in the degrees-minutes-seconds system. The rest is just simple formatting. #-- 3 -- # [ latList := three formatted values of latDeg in # degrees/minutes/seconds # lonList := three formatted values of lonDeg similarly ] latList = dmsUnits.format ( dmsUnits.singleToMix(latDeg), 1 ) lonList = dmsUnits.format ( dmsUnits.singleToMix(lonDeg), 1 ) #-- 4 -- return ( '[%sd %s\' %s" %s Lat %sd %s\' %s" %s Lon]' % (latList[0], latList[1], latList[2], n_s, lonList[0], lonList[1], lonList[2], e_w) )
<code >class JulianDate</code >: Julian calendar timestamp For a discussion of the Julian date system, see the specification. # - - - - - c l a s s J u l i a n D a t e class JulianDate: """Class to represent Julian-date timestamps. State/Invariants: .f: [ (Julian date as a float) - JULIAN_BIAS ] """
<code >JulianDate.__init__()</code >: Constructor The value represented is the some of the two arguments (the second of which default to zero), but JULIAN_BIAS is subtracted before the two argument values are added, to avoid loss of significance. # - - - J u l i a n D a t e . _ _ i n i t _ _ def __init__ ( self, j, f=0.0 ): """Constructor for JulianDate. """ self.j = j - JULIAN_BIAS + f
<code >JulianDate.__float__()</code >: Convert to a float This method adds JULIAN_BIAS to the internal value so that it is the standard value. # - - - J u l i a n D a t e . _ _ f l o a t _ _ def __float__ ( self ): """Convert self to a float. """ return self.j + JULIAN_BIAS
<code >JulianDate.datetime()</code >: Convert to a <code >datetime</code > Converts a JulianDate instance to a Python datetime value. The algorithm here is rather inscrutable; refer to Duffett-Smith for the details. # - - - J u l i a n D a t e . d a t e t i m e def datetime ( self ): """Convert to a standard Python datetime object in UT. """ Step 1 of the algorithm reads: “Add 0.5 to JD. Set I=integer part and F=fractional part.” Once we have extracted the fractional days part, we can safely add the JULIAN_BIAS back in with no loss of significance. #-- 1 -- # [ i := int(self.j + 0.5) # f := (self.j + 0.5) % 1.0 ] i, f = divmod ( self.j + 0.5, 1.0 ) i += JULIAN_BIAS Step 2: “If I is larger than 2,299,160, calculate A = integer part of ((I- 1,867,216.25) / 36,524.25); calculate B = I + 1 + a - integer part of (A/4); otherwise set A = I.” The last part of this sentence should probably set “...otherwise set B = I,” since A is not referenced after this step, but B certainly is. #-- 2 -- if i > 2299160: a = int((i-1867216.25)/36524.25) b = i + 1 + a - int ( a / 4.0 ) else: b = i Step 3: “Calculate C = B + 1524.” #-- 3 -- c = b + 1524 Step 4: “Calculate D = integer part of (C-122.1)/365.25.” #-- 4 -- d = int((c-122.1)/365.25) Step 5: “Calculate E = integer part of (365.25 × D ).” #-- 5 -- e = int(365.25*d) Step 6: “Calculate G = integer part of ((C-E)/30.6001).” #-- 6 -- g = int((c-e)/30.6001) Step 7: “Calculate d=C-E+F-integer part of (30.6001 × G). This is the day of the month, including the decimal fraction of the day.” We will remove the fractional day and convert it to hours, minutes, and seconds. #-- 7 -- dayFrac = c - e + f - int ( 30.6001 * g ) day, frac = divmod ( dayFrac, 1.0 ) dd = int(day) hr, mn, sc = dmsUnits.singleToMix ( 24.0*frac ) Step 8: “Calculate m=G-1 if G is less than 13.5, or m=G-13 if G is more than 13.5. This is the month number.” #-- 8 -- if g < 13.5: mm = int(g - 1) else: mm = int(g - 13) Step 9: “Calculate y = D-4716 if m is more than 2.5, or y = D - 4715 if m is less than 2.5. This is the year.” #-- 9 -- if mm > 2.5: yyyy = int(d-4716) else: yyyy = int(d-4715) Now that we have all the pieces, assemble them into a datetime and return it. One further elaboration: the value of sc is a float, and the datetime.datetime() constructor wants fractional seconds passed as a “microseconds” argument. #-- 10 -- sec, fracSec = divmod(sc, 1.0) usec = int(fracSec * 1e6) return datetime.datetime ( yyyy, mm, dd, hr, mn, int(sec), usec )
<code >JulianDate.offset()</code >: Move a time by some number of days For a JulianDate instance JD, this method returns a new JulianDate instance that differs by delta days. # - - - J u l i a n D a t e . o f f s e t def offset ( self, delta ): """Return a new JulianDate for self+(delta days) [ delta is a number of days as a float -> return a new JulianDate (delta) days in the future, or past if negative ] """ To preserve the precision, we'll perform the addition directly on the internal value that is biased by JULIAN_BIAS, then separate the sum into whole part and fraction, and then un-bias the whole part and pass both to the class constructor. #-- 1 -- newJ = self.j + delta #-- 2 -- # [ newWhole := whole part of newJ # newFrac := fractional part of newJ ] newWhole, newFrac = divmod ( newJ ) #-- 3 -- return JulianDate ( newWhole+JULIAN_BIAS, newFrac )
<code >JulianDate.__sub__()</code >: Difference of two Julian dates The other must be a JulianDate instance. The return value is the difference in days. # - - - J u l i a n D a t e . _ _ s u b _ _ def __sub__ ( self, other ): """Implement subtraction. [ other is a JulianDate instance -> return self.j - other.j ] """ return self.j - other.j
<code >JulianDate.__cmp__()</code >: Compare two Julian dates The ordinary Python comparison function. # - - - J u l i a n D a t e . _ _ c m p _ _ def __cmp__ ( self, other ): """Compare two instances. [ other is a JulianDate instance -> if self.j < other.j -> return a negative number else if self.j == other.j -> return zero else -> return a positive number ] """ return cmp ( self.j, other.j )
<code >JulianDate.fromDatetime()</code >: Convert a <code >datetime</code > to a Julian date This static method converts a JulianDate instance JD to one of Python's regular datetime objects. In Duffett-Smith, this is section 4. This method handles both “naive” and “aware” datetime instances. You may want to review these concepts in the online documentation for datetime. A naive instance is assumed to represent UTC. For an aware instance, we will use its .utcoffset() method to convert it to UTC. # - - - J u l i a n D a t e . f r o m D a t e t i m e # @staticmethod def fromDatetime ( dt ): """Create a JulianDate instance from a datetime.datetime. [ dt is a datetime.datetime instance -> if dt is naive -> return the equivalent new JulianDate instance, assuming dt expresses UTC else -> return a new JulianDate instance for the UTC time equivalent to dt ] """ The first step is to derive the UTC equivalent to dt. The documentation states that the return value from .utcoffset() is one of: None, if the instance is naive. A datetime.timedelta instance representing the offset in hours east of London. This value must be subtracted from a local time to get UTC. Note that subtracting a timedelta instance from a datetime instance yields a new datetime instance. #-- 1 -- # [ if dt is naive -> # utc := dt # else -> # utc := dt - dt.utcoffset() ] utc = dt offset = dt.utcoffset() if offset: utc = dt - offset We synthesize a fractional day from the hours, minutes, seconds, and microseconds attributes. For the conversion of hours/minutes/seconds to hours, see ; the resulting hours are divided by 24.0 to get days. #-- 2 -- # [ fracDay := fraction of a day in [0.0,1.0) made from # utc.hour, utc.minute, utc.second, and utc.microsecond ] s = float(utc.second) + float(utc.microsecond)*1e-6 hours = dmsUnits.mixToSingle ( (utc.hour, utc.minute, s) ) fracDay = hours / 24.0 We extract the year, month, and day from utc. This is Step 1 from the book. #-- 3 -- y = utc.year m = utc.month d = utc.day Step 2: “If m=1 or m=2 subtract 1 from y and add 12 to m. Otherwise y'=y and m'=m.” Rather than having separate variables for y' and m', we'll just modify variables y and d in place. #-- 4 -- if m <= 2: y, m = y-1, m+12 Step 3: “If the date is later than 1582 October 15 (i.e., Gregorian calendar) calculate: (i) A = integer part of (y'/100); (ii) B = 2 - A + integer part of (A/4). Otherwise B = 0.” Note how easy it is to compare dates in mixed units: Python defines ordering on tuples in the correct way. #-- 5 -- if ( (y, m, d) >= (1582, 10, 15) ): A = int ( y / 100 ) B = 2 - A + int ( A / 4 ) else: B = 0 Step 4: “Calculate C = integer part of (365.25×y').” Step 5: “Calculate D = integer part of (30.6001×(m'+1)).” #-- 6 -- C = int ( 365.25 * y ) D = int ( 30.6001 * ( m + 1 ) ) Step 6: “Find JD = B + C + D + d + 1 720 994.5. This is the Julian date.” To preserve extra precision over a purely float representation of the Julian date, we will do the addition of the last constant in multiple steps. First we'll add the 0.5 fractional part to fracDay and, if that sum exceeds 1.0, add the carry to the day number d, retaining the fractional part in fracDay. Then we'll add the remaining parts together to get the whole part. #-- 7 -- # [ if fracDay+0.5 >= 1.0 -> # s += 1 # fracDay := (fracDay+0.5) % 1.0 # else -> # fracDay := fracDay + 0.5 ] dayCarry, fracDay = divmod ( fracDay+0.5, 1.0 ) d += dayCarry #-- 8 -- j = B + C + D + d + 1720994 #-- 9 -- return JulianDate ( j, fracDay ) This next line is necessary to designate this method as a static method. fromDatetime = staticmethod(fromDatetime)
<code >class SiderealTime</code >: Sidereal time An instance of this class represents a plain sidereal time in the range [0,24) hours. No attempt is made inside the object to record whether it represents Greenwich sidereal time (GST) or local sidereal time (LST). Although the constructor accepts a value in hours, internally the value is stored as radians normalized to the interval [0,2π). # - - - - - c l a s s S i d e r e a l T i m e class SiderealTime: """Represents a sidereal time value. State/Internals: .hours: [ self as 15-degree hours ] .radians: [ self as radians ] """
<code >SiderealTime.__init__()</code >: Constructor The time in hours is first normalized to the interval [0,24) and stored in self.hours, then converted to radians and stored in self.radians. # - - - S i d e r e a l T i m e . _ _ i n i t _ _ def __init__ ( self, hours ): """Constructor for SiderealTime """ self.hours = hours % 24.0 self.radians = hoursToRadians ( self.hours )
<code >SiderealTime.__str__()</code >: Convert to string To convert from decimal hours to mixed units and format them with left zero, we use . # - - - S i d e r e a l T i m e . _ _ s t r _ _ def __str__ ( self ): """Convert to a string such as "[04h 40m 5.170s]". """ #-- 1 -- # [ values := self.hours as a list of mixed units # in dmsUnits terms, formatted as left-zero # filled strings with 3 digits after the decimal ] mix = dmsUnits.singleToMix ( self.hours ) values = dmsUnits.format ( mix, decimals=3, lz=True ) #-- 2 -- return "[%sh %sm %ss]" % tuple(values)
<code >SiderealTime.utc()</code >: Find Universal Time This method finds the first or only time on a given date when self's Greenwich Sidereal Time (GST) occurs. The date is provided as a datetime.date instance. In Duffett-Smith, this is section 13. # - - - S i d e r e a l T i m e . u t c def utc ( self, date ): """Convert GST to UTC. [ date is a UTC date as a datetime.date instance -> return the first or only time at which self's GST occurs at longitude 0 ] """ “Step 1: Find the number of days between January 0.0 and the date in question.” See . #-- 1 -- # [ nDays := number of days between Jan. 0 of year # (date.year) and date ] nDays = dayNo ( date ) Step 2 is to multiply that by constant A, which in this script is defined in . Step 3 is to subtract factor B, which is a function of the year number; for the computation of this factor, see . Normalize the result of step 3 to range [0,24). This is factor T0. #-- 2 -- # [ t0 := (nDays * A - B(date.year)), normalized to # interval [0,24) ] t0 = ( ( nDays * SIDEREAL_A - SiderealTime.factorB ( date.year ) ) % 24.0 ) Step 4 is to convert the GST to decimal hours. Step 5 is subtract T0, and renormalize to the interval [0,24). #-- 3 -- # [ t1 := ((self in decimal hours)-t0), normalized to # the interval [0,24) ] t1 = ( radiansToHours ( self.radians ) - t0 ) % 24.0 Step 6: “Multiply by constant D (0.997 270). This is the GMT in hours.” #-- 4 -- gmtHours = t1 * 0.997270 The result is to be expressed as a datetime.datetime instance. The date portion of this result is just a copy of the date argument. We'll use dmsUnits (see ) to convert whole hours to hours, minutes, and seconds, then break out the microseconds as required by datetime.datetime. #-- 5 -- # [ dt := a datetime.datetime instance whose date comes # from (date) and whose time is (gmtHours) # decimal hours ] hour, minute, floatSec = dmsUnits.singleToMix ( gmtHours ) wholeSec, fracSec = divmod ( floatSec, 1.0 ) second = int ( wholeSec ) micros = int ( fracSec * 1e6 ) dt = datetime.datetime ( date.year, date.month, date.day, hour, minute, second, micros ) #-- 6 -- return dt
<code >SiderealTime.factorB()</code >: Compute sidereal time factor B (static method) The number B is used in and . The algorith is given in section 12 of Duffett-Smith. It is a function of the year, and expresses the GST at 0:00 on January 0 of the year. # - - - S i d e r e a l T i m e . f a c t o r B # @staticmethod def factorB ( yyyy ): """Compute sidereal conversion factor B for a given year. [ yyyy is a year number as an int -> return the GST at time yyyy-01-00T00:00 ] """ Step 1: “Calculate the Julian date of January 0.0 of year in question.” Unfortunately, we can't just blithely pass the datetime.datetime() constructor that date, because it's not a proper date (“ValueError: day is out of range for month”). So we'll get around that by finding the JD of Jan. 1, converting it to a float, and subtracting 1.0. #-- 1 -- # [ janJD := the Julian date of January 0.0 of year # (yyyy), as a float ] janDT = datetime.datetime ( yyyy, 1, 1 ) janJD = float(JulianDate.fromDatetime(janDT)) - 1.0 Steps 2–4 are exactly as described in Duffett-Smith, except that we rearrange the polynomial (6.646 065 6+(2400.051 262×T)+(0.000 025 81×T2) to the computationally more straightforward form. #-- 2 -- s = janJD - 2415020.0 #-- 3 -- t = s / 36525.0 #-- 4 -- r = ( 0.00002581 * t + 2400.051262 ) * t + 6.6460656 Step 5: “Calculate U=R-(24×(year-1900)).” Step 6: “Subtract U from 24. This is B.” #-- 5 -- u = r - 24 * ( yyyy-1900) #-- 6 -- return 24.0 - u factorB = staticmethod(factorB)
<code >SiderealTime.gst()</code >: Local to Greenwich sidereal In Duffett-Smith, this is section 15. # - - - S i d e r e a l T i m e . g s t def gst ( self, eLong ): """Convert LST to GST. [ self is local sidereal time at longitude eLong radians east of Greenwich -> return the equivalent GST as a SiderealTime instance ] """ If we convert the longitude eLong to hours, this function becomes a simple matter of subtracting the longitude from the LST and normalizing to the interval [0,24). #-- 1 -- # [ deltaHours := eLong expressed in hours ] deltaHours = radiansToHours ( eLong ) #-- 2 -- gstHours = ( self.hours - deltaHours ) % 24.0 #-- 3 -- return SiderealTime ( gstHours )
<code >SiderealTime.lst()</code >: Greenwich to local sidereal This is the inverse of : self is assumed to be GST, and we want to find the equivalent LST. All we have to do is add the longitude to the GST and renormalize to [0,24). # - - - S i d e r e a l T i m e . l s t def lst ( self, eLong ): """Convert GST to LST. [ (self is Greenwich sidereal time) and (eLong is a longitude east of Greenwich in radians) -> return a new SiderealTime representing the LST at longitude eLong ] """ #-- 1 -- # [ deltaHours := eLong expressed in hours ] deltaHours = radiansToHours ( eLong ) #-- 2 -- gmtHours = (self.hours + deltaHours) % 24.0 #-- 3 -- return SiderealTime ( gmtHours )
<code >SiderealTime.fromDatetime()</code >: Convert UTC to GST (static method) Given a datetime.datetime instance dt, this method returns the Greenwich Sidereal Time at the UTC time represented by dt. In Duffett-Smith, this is section 12. Constant C is defined as “1.002 738”. # - - - S i d e r e a l T i m e . f r o m D a t e t i m e SIDEREAL_C = 1.002738 # @staticmethod def fromDatetime ( dt ): """Convert civil time to Greenwich Sidereal. [ dt is a datetime.datetime instance -> if dt has time zone information -> return the GST at the UTC equivalent to dt else -> return the GST assuming dt is UTC ] """ First we have to convert dt to UTC. This involves finding out whether dt is naive (devoid of time zone information) or aware (fully supplied with time zone information). According to the documentation for Python's datetime module, the test for awareness has two parts: the instance's tzinfo attribute must be not None, and dt.tzinfo.utcoffset(dt) must not be None. If both these conditions are true, the value returned by dt.tzinfo.utcoffset(dt) is the difference between UTC and the local time: positive for local times east of Greenwich, negative for west. The value may be either a number expressed in minutes, or a datetime.timedelta instance, with the shift expressed in minutes. In either case, we can subtract the value from dt to get the UTC as a new datetime.datetime instance. #-- 1 -- # [ if dt is naive -> # utc := dt # else -> # utc := the UTC time equivalent to dt ] utc = dt tz = dt.tzinfo if tz is not None: offset = tz.utcoffset ( dt ) if offset is not None: utc = dt - offset Step 1 in Duffett-Smith says: “Find the number of days between January 0.0 and the date in question.” See . #-- 2 -- # [ nDays := number of days between January 0.0 and utc ] nDays = dayNo ( utc ) In steps 2-3, we compute T0 as (nDays×A-B). For constant A, see . Factor B is a function of the year number, and is computed in . #-- 3 -- t0 = ( nDays * SIDEREAL_A - SiderealTime.factorB ( utc.year ) ) Step 4: “Convert GMT to decimal hours.” This conversion uses . #-- 4 -- # [ decUTC := utc as decimal hours ] floatSec = utc.second + float ( utc.microsecond ) / 1e6 decUTC = dmsUnits.mixToSingle ( (utc.hour, utc.minute, floatSec) ) Step 5: “Multiply by constant C.”, which is defined as “1.002 738”. Step 6: “Add this to T0,” which, normalized to the interval [0,24), is the GST in hours. The result is returned as a SiderealTime instance. #-- 4 -- # [ gst := (decUTC * C + t0), normalized to interval [0,24) ] gst = ( decUTC * SiderealTime.SIDEREAL_C + t0) % 24.0 #-- 5 -- return SiderealTime ( gst ) This is a static method. fromDatetime = staticmethod ( fromDatetime )
<code >class AltAz</code >: Horizon coordinates An instance of this class represents a location relative to where a particular observer is standing at a particular time. Altitude is the distance above the horizon, and azimuth is the compass direction, 0° for north, 90° for east, and so on. # - - - - - c l a s s A l t A z class AltAz: """Represents a sky location in horizon coords. (altitude/azimuth) Exports/Invariants: .alt: [ altitude in radians, in [-pi,+pi] ] .az: [ azimuth in radians, in [0,2*pi] ] """
<code >AltAz.__init__()</code >: Constructor The constructor is pro-forma: just save the arguments in the instance's namespace. # - - - A l t A z . _ _ i n i t _ _ def __init__ ( self, alt, az ): """Constructor for AltAz, horizon coordinates. [ (alt is an altitude in radians) and (az is an azimuth in radians) -> return a new AltAz instance with those values, normalized as per class invariants ] """ self.alt = alt self.az = az
<code >AltAz.raDec()</code >: Horizon to equatorial coordinates For a given observer's location and time, this method returns, as a RADec instance, the equatorial coordinates corresponding to self's horizon coordinates. In Duffett-Smith, this is section 26. Here are the relevant formulae: a Altitude. A Azimuth. φ The observer's geographic latitude. δ Declination. H Hour angle. # - - - A l t A z . r a D e c def raDec ( self, lst, latLon ): """Convert horizon coordinates to equatorial. [ (lst is a local sidereal time as a SiderealTime instance) and (latLon is the observer's position as a LatLon instance) -> return the corresponding equatorial coordinates as a RADec instance ] """ As Duffett-Smith points out, the horizon-to-equatorial conversion in either direction uses the same formula. Hence, the actual calculation of δ and H is handled by . #-- 1 -- # [ dec := declination of self at latLon in radians # hourRadians := hour angle of self at latlon in radians ] dec, hourRadians = coordRotate ( self.alt, latLon.lat, self.az ) #-- 2 -- # [ hourRadians is an hour angle in radians -> # h := hourRadians in hours ] h = radiansToHours ( hourRadians ) The conversion of hour angle and LST to right ascension uses the same technique as in : subtract the hour angle from the LST, and normalize. Then we convert it to radians, instantiate an RADec, and return the instance. #-- 3 -- # [ ra := right ascension for hour angle (h) at local # sidereal time (lst) and location (latLon) ] ra = hoursToRadians ( ( lst.hours - h ) % 24.0 ) #-- 4 -- return RADec ( ra, dec )
<code >AltAz.__str__()</code >: Convert to a string The return value has this form: [az NNNd NN' NN.NNN" alt NNd NN' NN.NNN"] # - - - A l t A z . _ _ s t r _ _ def __str__ ( self ): """Convert self to a string. """ Conversion and formatting as mixed units is handled by . #-- 1 -- # [ altList := self.alt, formatted as degrees, minutes, # and seconds # azList := self.az, formatted as degrees, minutes, and # seconds ] altList = dmsUnits.format ( dmsUnits.singleToMix ( degrees(self.alt) ), lz=True, decimals=3 ) azList = dmsUnits.format ( dmsUnits.singleToMix ( degrees(self.az) ), lz=True, decimals=3 ) #-- 2 -- return ( "[az %sd %s' %s\" alt %sd %s' %s\"]" % (tuple(azList)+tuple(altList)) )
<code >coordRotate()</code >: Rotation of spherical coordinates This function is used by both and . Refer to those sections for the relevant formulae. # - - - c o o r d R o t a t e def coordRotate ( x, y, z ): """Used to convert between equatorial and horizon coordinates. [ x, y, and z are angles in radians -> return (xt, yt) where xt=arcsin(sin(x)*sin(y)+cos(x)*cos(y)*cos(z)) and yt=arccos((sin(x)-sin(y)*sin(xt))/(cos(y)*cos(xt))) ] """ Step 1: Find sin xt = sin x siny + cos x cosy cos z. Step 2: Take inverse sine to find xt. #-- 1 -- xt = asin ( sin(x) * sin(y) + cos(x) * cos(y) * cos(z) ) Step 3: Find cos yt = (sin x - sin y sinxt) / (cos y cos xt ). Step 4: Take inverse cos to find yt. #-- 2 -- yt = acos ( ( sin(x) - sin(y) * sin(xt) ) / ( cos(y) * cos(xt) ) ) Next we must remove the ambiguity caused by the computation of inverse cosine. The rule here is that if sin(z) is posive, we must replace yt by 2π-yt. #-- 3 -- if sin(z) > 0.0: yt = TWO_PI - yt #-- 4 -- return (xt, yt)
<code >class RADec</code >: Equatorial coordinates # - - - - - c l a s s R A D e c class RADec: """Represents a celestial location in equatorial coordinates. Exports/Invariants: .ra: [ right ascension in radians ] .dec: [ declination in radians ] """
<code >RADec.__init__()</code >: Constructor # - - - R A D e c . _ _ i n i t _ _ def __init__ ( self, ra, dec ): """Constructor for RADec. """ self.ra = ra % TWO_PI self.dec = dec
<code >RADec.hourAngle()</code >: Find the hour angle This is a convenience function that returns the hour angle for a specific time utc and longitude eLong. # - - - R A D e c . h o u r A n g l e def hourAngle ( self, utc, eLong ): """Find the hour angle at a given observer's location. [ (utc is a Universal Time as a datetime.datetime) and (eLong is an east longitude in radians) -> return the hour angle of self at that time and longitude, in radians ] """ The work is passed along to the standalone function . return raToHourAngle ( self.ra, utc, eLong )
<code >RADec.altAz()</code >: Equatorial to horizon coordinates In Duffett-Smith, this is section 25. Here are the equations defining the transformation: For the definitions of the symbols, see . # - - - R A D e c . a l t A z def altAz ( self, h, lat ): """Convert equatorial to horizon coordinates. [ (h is an object's hour angle in radians) and (lat is the observer's latitude in radians) -> return self's position in the observer's sky in horizon coordinates as an AltAz instance ] """ As in , we will delegate most of the work to . #-- 1 -- # [ alt := altitude of self as seen from latLon at utc # az := azimuth of self as seen from latLon at utc ] alt, az = coordRotate ( self.dec, lat, h ) #-- 2 -- return AltAz ( alt, az )
<code >RADec.__str__()</code >: Convert to a string This method displays the coordinates in user-friendly units. # - - - R A D e c . _ _ s t r _ _ def __str__ ( self ): """Return self as a string. """ #-- 1 -- # [ raUnits := units of self.ra as hours/minutes/seconds # decUnits := units of self.dec as degrees/minutes/seconds raUnits = dmsUnits.format ( dmsUnits.singleToMix ( radiansToHours(self.ra) ), lz=True, decimals=3 ) decUnits = dmsUnits.format ( dmsUnits.singleToMix ( degrees(self.dec) ), lz=True, decimals=3 ) #-- 2 -- return ( "[%sh %sm %ss, %sd %s' %s\"]" % (tuple(raUnits)+tuple(decUnits)) )
Regression tests This section contains a number of small scripts that exercise the &py; module. Their names are keyed to the section numbers in Duffett-Smith, except for tests of modules that are not from the book.
<code >testmix</code >: Test <code >MixedUnits</code > This script exercises the MixedUnits class by using it to convert various mixed values in the days-hours-minutes-seconds system, convert them back, and format them with and without left zero fill. #!/usr/bin/env python #================================================================ # testmix: Exercise the MixedUnits class. # For documentation, see: # &selfURL; #---------------------------------------------------------------- from sidereal import * dhmsSystem = MixedUnits ( (24, 60, 60) ) testValues = [ (), (3.9,), (2,12), (1,4,10), (0,1,30,15), (1, 2, 3, 4, 5), # Not valid (1, 0, 0, 59.999999), (1, 0, 0, 59.9), (1, 2, 3, 59.5), (1, 0, 0, 59.499999) ] def test(seq): """Test one tuple. """ #-- # Convert the sequence to a single value. This can fail # if the sequence is too long. #-- try: single = dhmsSystem.mixToSingle(seq) except ValueError, detail: print "Bad value:", detail return #-- # Convert it back to a sequence, and show all three values. # Then format it in a range of precisions, with/without zeroes. #-- check = dhmsSystem.singleToMix(single) print "%s -> %s -> %s" % (seq, single, check) for digits in range(4): noZeroes = dhmsSystem.format ( check, digits ) withZeroes = dhmsSystem.format ( check, digits, lz=True ) print " %d %s %s" % (digits, noZeroes, withZeroes) #================================================================ # Main #---------------------------------------------------------------- for valueList in testValues: test(valueList)
<code >test4-5</code >: Converting to and from Julian day This script tests JulianDate.fromDatetime() and JulianDate.datetime(), algorithms 4 and 5 respectively in Duffett-Smith. #!/usr/bin/env python #================================================================ # test4-5: Test datetime <-> JulianDate conversion. # For documentation, see: # &selfURL; #---------------------------------------------------------------- import datetime from sidereal import * #-- # First make a datetime.datetime from 1985-02-17T06:00. #-- dt = datetime.datetime ( 1985, 2, 17, 6 ) print "Input datetime:", dt #-- # Convert to Julian Date and display. #-- jd = JulianDate.fromDatetime(dt) print float(jd) #-- # Convert back to a datetime object and display that. #-- check = jd.datetime() print "Check datetime:", check
<code >test12-13</code >: GMT to GST and back The example for section 12 in Duffett-Smith, conversion of GMT to GST, is: What was the GST at 14h 36m 51.67s on April 22nd 1980? Their answer is 04h, 40m, 5.17s. #!/usr/bin/env python #================================================================ # test12-13: Test GMT <-> GST conversion. # For documentation, see: # &selfURL; #---------------------------------------------------------------- import datetime import sidereal #-- # Create a datetime for 1980-04-22T14:36:51.67. #-- dt = datetime.datetime ( 1980, 4, 22, 14, 36, 51, 670000 ) print "Start date:", dt #-- # Convert dt to GST. #-- gst = sidereal.SiderealTime.fromDatetime ( dt ) print "GST:", gst #-- # Convert GST back to a datetime. #-- check = gst.utc(dt) print "Check date:", check
<code >test14-15</code >: Converting between GST and LST Here's the book's example for GST to LST; the second half is just the same conversion reversed.
What is the local sidereal time on the longitude 64° W when the Greenwich sidereal time is 4h 40m 5.17s?
The book's answer is 0h 24m 5.17s. #!/usr/bin/env python #================================================================ # test14-15: Test GST <-> LST conversion. # For documentation, see: # &selfURL; #---------------------------------------------------------------- import math import datetime import sidereal #-- # First we used MixedUnits to convert 4h 40m 5.17s to decimal hours. #-- dmsUnits = sidereal.MixedUnits ( (60, 60) ) gstHours = dmsUnits.mixToSingle ( (4, 40, 5.17) ) gst = sidereal.SiderealTime ( gstHours ) print "GST is", gst #-- # Convert 64 degrees W to radians of E. Long. #-- eLong = math.radians ( -64.0 ) print "Longitude east of Greenwich is", math.degrees(eLong) #-- # Convert GST to LST. #-- lst = gst.lst ( eLong ) print "LST is", lst #-- # Convert LST back to GST. #-- check = lst.gst ( eLong ) print "Check GST is", check
<code >test24</code >: Converting between right ascension and hour angle This test has two parts; the second part is the reverse conversion from the first part.
Find the local hour-angle of a star whose right ascension is α=18h 32m 21s, at a point whose longitude is 64° W, on April 22nd 1980 at 14h 36m 51.67s GMT. Answer: 5h 51m 44s.
#!/usr/bin/env python #================================================================ # test24: Convert from right ascension to hour angle and back. # For documentation, see: # &selfURL; #---------------------------------------------------------------- import sys from math import * import datetime import sidereal First we convert the value of α to radians. For the conversion of mixed units to degrees, see ; radians() is from Python's math module and converts degrees to radians. Next we convert 64° to radians. Then we make a datetime.datetime instance for the given time. # - - - m a i n def main(): """Main program. """ global dmsUnits #-- 1 -- # [ dmsUnits := a MixedUnits instance for factor list (60,60) ] dmsUnits = sidereal.MixedUnits ( (60, 60) ) #-- 2 -- # [ ra := (18h 32m 21s) in radians # eLong := 64 degrees as radians # dt := 14h 36m 51.67s GMT as a datetime.datetime ] raHours = dmsUnits.mixToSingle((18,32,21)) ra = sidereal.hoursToRadians(raHours) eLong = radians(-64.0) dt = datetime.datetime ( 1980, 4, 22, 14, 36, 51, 670000 ) print "Right ascension:", radHMS(ra) print "Longitude:", radDMS(eLong) print "UTC:", dt The function returns the hour angle in radians; we'll format it in degrees, minutes, and second for display. #-- 3 -- # [ hRadians := hour angle in radians for right ascension (ra), # time (dt), and longitude (eLong) ] hRadians = sidereal.raToHourAngle ( ra, dt, eLong ) #-- 4 -- # [ sys.stdout +:= hRadians displayed as deg/min/sec ] print "Hour angle:", radHMS(hRadians) Now, the inverse test. #-- 5 -- # [ check := right ascension for hour angle (hRadians), # time (dt), and longitude (eLong) ] checkRadians = sidereal.hourAngleToRA ( hRadians, dt, eLong ) #-- 6 -- # [ sys.stdout +:= checkRadians displayed as d/m/s ] raDec = radHMS ( checkRadians ) print "Check RA:", radHMS ( checkRadians ) This subroutine is used to display radians as degrees, minutes, and seconds. # - - - r a d D M S def radDMS(rad): """Display radians as degrees, minutes, and seconds. """ valueList = dmsUnits.format ( dmsUnits.singleToMix(degrees(rad)), lz=True, decimals=3 ) return "%sd %s' %s\"" % tuple(valueList) This subroutine displays radians as hours, minutes, and seconds. # - - - r a d H M S def radHMS(rad): """Display radians as hours, minutes, and seconds. """ valueList = dmsUnits.format ( dmsUnits.singleToMix ( sidereal.radiansToHours(rad) ), lz=True, decimals=3 ) return "%sh %sm %ss" % tuple(valueList) #================================================================ # Epilogue #---------------------------------------------------------------- if __name__ == "__main__": main()
<code >test25-26</code >: Equatorial to horizon coordinates and back This script exercises and , sections 25 and 26 of Duffett-Smith. Here is the problem statement for the forward conversion; the book's answer is a=19° 20′ 02″, A=283° 16′ 18″.
What are the altitude and azimuth of a star whose hour-angle is 05h 51m 44s and declination is 23° 13′ 10″? The observer's latitude is 52° N.
#!/usr/bin/env python #================================================================ # test25-26: Test equatorial <-> horizon coordinates. # For documentation, see: # &selfURL; #---------------------------------------------------------------- import math import datetime import sidereal First we set up a MixedUnits instance to do mixed-unit conversion and formatting. Then we set up the inputs: the equatorial coordinates, the hour angle, and the observer's latitude. #-- # Converter for mixed units #-- dmsUnits = sidereal.MixedUnits ( (60, 60) ) #-- # Set up inputs #-- dec = math.radians ( dmsUnits.mixToSingle ( (23, 13, 10) ) ) raDec = sidereal.RADec ( 0.0, dec ) hHours = dmsUnits.mixToSingle ( (5, 51, 44) ) hRadians = sidereal.hoursToRadians ( hHours ) lat = math.radians ( 52.0 ) latLon = sidereal.LatLon ( lat, 0.0 ) The result returned by RADec.altAz is an AltAz instance, which we then display. #-- # Convert to horizon coordinates #-- altAz = raDec.altAz ( hRadians, lat ) print "Horizon coordinates:", altAz Finally we do the back-conversion. #-- # Convert back to an hour angle. #-- gst = sidereal.SiderealTime ( dmsUnits.mixToSingle ( (0, 24, 05) ) ) check = altAz.raDec ( gst, latLon ) print "Check RA/Dec:", check