def mean_longitude_perigee(self, jd): """Return mean longitude of lunar perigee """ T = jd_to_jcent(jd) X = polynomial( (d_to_r(83.3532465), d_to_r(4069.0137287), d_to_r(-0.0103200), d_to_r(-1. / 80053), d_to_r(1. / 18999000)), T) return modpi2(X)
def mean_longitude_perigee(self, jd): """Return mean longitude of lunar perigee """ T = jd_to_jcent(jd) X = polynomial( (d_to_r(83.3532465), d_to_r(4069.0137287), d_to_r(-0.0103200), d_to_r(-1./80053), d_to_r(1./18999000) ), T) return modpi2(X)
def nutation_in_obliquity(jd): """Return the nutation in obliquity. High precision. [Meeus-1998: pg 144] Arguments: - `jd` : Julian Day in dynamical time Returns: - nutation in obliquity, in radians """ # # Future optimization: factor the /1e5 and /1e6 adjustments into the table. # # Could turn the loop into a generator expression. Too messy? # T = jd_to_jcent(jd) D, M, M1, F, omega = _constants(T) deltaEps = 0.0 for tD, tM, tM1, tF, tomega, tpsiK, tpsiT, tepsK, tepsT in _tbl: arg = D*tD + M*tM + M1*tM1 + F*tF + omega*tomega deltaEps = deltaEps + (tepsK/10000.0 + tepsT/100000.0 * T) * np.cos(arg) deltaEps = deltaEps / 3600 deltaEps = d_to_r(deltaEps) return deltaEps
def equinox_approx(yr, season): """Returns the approximate time of a solstice or equinox event. The year must be in the range -1000...3000. Within that range the the error from the precise instant is at most 2.16 minutes. Parameters: yr : year season : one of ("spring", "summer", "autumn", "winter") Returns: Julian Day of the event in dynamical time """ if not (-1000 <= yr <= 3000): raise Error, "year is out of range" if season not in astronomia.globals.season_names: raise Error, "unknown season =" + season yr = int(yr) if -1000 <= yr <= 1000: Y = yr / 1000.0 tbl = _approx_1000 else: Y = (yr - 2000) / 1000.0 tbl = _approx_3000 jd = polynomial(tbl[season], Y) T = jd_to_jcent(jd) W = d_to_r(35999.373 * T - 2.47) delta_lambda = 1 + 0.0334 * cos(W) + 0.0007 * cos(2 * W) jd += 0.00001 * sum([A * cos(B + C * T) for A, B, C in _terms]) / delta_lambda return jd
def _latitude(self, jd): """Return the geocentric ecliptic latitude in radians. A subset of the logic in dimension3() """ T = jd_to_jcent(jd) L1, D, M, M1, F, A1, A2, A3, E, E2 = _constants(T) bsum = 0.0 for tD, tM, tM1, tF, tb in _tblB: arg = tD * D + tM * M + tM1 * M1 + tF * F if abs(tM) == 1: tb *= E elif abs(tM) == 2: tb *= E2 bsum += tb * sin(arg) bsum += -2235 * sin(L1) + \ 382 * sin(A3) + \ 175 * sin(A1 - F) + \ 175 * sin(A1 + F) + \ 127 * sin(L1 - M1) - \ 115 * sin(L1 + M1) latitude = d_to_r(bsum / 1000000) return latitude
def nut_in_lon(jd): """Return the nutation in longitude. High precision. [Meeus-1998: pg 144] Parameters: jd : Julian Day in dynamical time Returns: nutation in longitude, in radians """ # # Future optimization: factor the /1e5 and /1e6 adjustments into the table. # # Could turn the loop into a generator expression. Too messy? # T = jd_to_jcent(jd) D, M, M1, F, omega = _constants(T) deltaPsi = 0.0 for tD, tM, tM1, tF, tomega, tpsiK, tpsiT, tepsK, tepsT in _tbl: arg = D*tD + M*tM + M1*tM1 + F*tF + omega*tomega deltaPsi += (tpsiK/10000.0 + tpsiT/100000.0 * T) * sin(arg) deltaPsi /= 3600 deltaPsi = d_to_r(deltaPsi) return deltaPsi
def nutation_in_longitude(jd): """Return the nutation in longitude. High precision. [Meeus-1998: pg 144] Arguments: - `jd` : Julian Day in dynamical time Returns: - nutation in longitude, in radians """ # # Future optimization: factor the /1e5 and /1e6 adjustments into the table. # # Could turn the loop into a generator expression. Too messy? # T = jd_to_jcent(jd) D, M, M1, F, omega = _constants(T) deltaPsi = 0.0 for tD, tM, tM1, tF, tomega, tpsiK, tpsiT, tepsK, tepsT in _tbl: arg = D * tD + M * tM + M1 * tM1 + F * tF + omega * tomega deltaPsi += (tpsiK / 10000.0 + tpsiT / 100000.0 * T) * np.sin(arg) deltaPsi /= 3600 deltaPsi = d_to_r(deltaPsi) return deltaPsi
def nut_in_obl(jd): """Return the nutation in obliquity. High precision. [Meeus-1998: pg 144] Parameters: jd : Julian Day in dynamical time Returns: nutation in obliquity, in radians """ # # Future optimization: factor the /1e5 and /1e6 adjustments into the table. # # Could turn the loop into a generator expression. Too messy? # T = jd_to_jcent(jd) D, M, M1, F, omega = _constants(T) deltaEps = 0.0; for tD, tM, tM1, tF, tomega, tpsiK, tpsiT, tepsK, tepsT in _tbl: arg = D*tD + M*tM + M1*tM1 + F*tF + omega*tomega deltaEps = deltaEps + (tepsK/10000.0 + tepsT/100000.0 * T) * cos(arg) deltaEps = deltaEps / 3600 deltaEps = d_to_r(deltaEps) return deltaEps
def mean_longitude_ascending_node(self, jd): """Return mean longitude of ascending node Another equation from: * This routine is part of the International Astronomical Union's * SOFA (Standards of Fundamental Astronomy) software collection. * Fundamental (Delaunay) arguments from Simon et al. (1994) * Arcseconds to radians DOUBLE PRECISION DAS2R PARAMETER ( DAS2R = 4.848136811095359935899141D-6 ) * Milliarcseconds to radians DOUBLE PRECISION DMAS2R PARAMETER ( DMAS2R = DAS2R / 1D3 ) * Arc seconds in a full circle DOUBLE PRECISION TURNAS PARAMETER ( TURNAS = 1296000D0 ) * Mean longitude of the ascending node of the Moon. OM = MOD ( 450160.398036D0 -6962890.5431D0*T, TURNAS ) * DAS2R Current implemention in astronomia is from: PJ Naughter (Web: www.naughter.com, Email: [email protected]) Look in nutation.py for calculation of omega _ko = (d_to_r(125.04452), d_to_r( -1934.136261), d_to_r( 0.0020708), d_to_r( 1.0/450000)) Though the last term was left off... Will have to incorporate better... """ T = jd_to_jcent(jd) X = polynomial( (d_to_r(125.0445479), d_to_r(-1934.1362891), d_to_r(0.0020754), d_to_r(1.0/467441.0), d_to_r(1.0/60616000.0) ), T) return modpi2(X)
def mean_longitude(self, jd): """Return mean longitude. Parameters: jd : Julian Day in dynamical time Returns: Longitude in radians """ T = jd_to_jcent(jd) # From astrolabe #X = polynomial((d_to_r(100.466457), d_to_r(36000.7698278), d_to_r(0.00030322), d_to_r(0.000000020)), T) # From AA, Naughter # Takes T/10.0 X = polynomial((d_to_r(100.4664567), d_to_r(360007.6982779), d_to_r(0.03032028), d_to_r(1.0/49931), d_to_r(-1.0/15300), d_to_r(-1.0/2000000)), T/10.0) X = modpi2(X + pi) return X
def mean_longitude(self, jd): """Return mean longitude. Arguments: - `jd` : Julian Day in dynamical time Returns: - Longitude in radians """ jd = np.atleast_1d(jd) T = jd_to_jcent(jd) # From astrolabe #X = polynomial((d_to_r(100.466457), # d_to_r(36000.7698278), # d_to_r(0.00030322), # d_to_r(0.000000020)), T) # From AA, Naughter # Takes T/10.0 X = polynomial( (d_to_r(100.4664567), d_to_r(360007.6982779), d_to_r(0.03032028), d_to_r(1.0 / 49931), d_to_r(-1.0 / 15300), d_to_r( -1.0 / 2000000)), T / 10.0) X = modpi2(X + np.pi) return _scalar_if_one(X)
def mean_longitude(self, jd): """Return mean longitude. Arguments: - `jd` : Julian Day in dynamical time Returns: - Longitude in radians """ jd = np.atleast_1d(jd) T = jd_to_jcent(jd) # From astrolabe #X = polynomial((d_to_r(100.466457), # d_to_r(36000.7698278), # d_to_r(0.00030322), # d_to_r(0.000000020)), T) # From AA, Naughter # Takes T/10.0 X = polynomial((d_to_r(100.4664567), d_to_r(360007.6982779), d_to_r(0.03032028), d_to_r(1.0/49931), d_to_r(-1.0/15300), d_to_r(-1.0/2000000)), T/10.0) X = modpi2(X + np.pi) return _scalar_if_one(X)
def mean_longitude_ascending_node(self, jd): """Return mean longitude of ascending node Another equation from: * This routine is part of the International Astronomical Union's * SOFA (Standards of Fundamental Astronomy) software collection. * Fundamental (Delaunay) arguments from Simon et al. (1994) * Arcseconds to radians DOUBLE PRECISION DAS2R PARAMETER ( DAS2R = 4.848136811095359935899141D-6 ) * Milliarcseconds to radians DOUBLE PRECISION DMAS2R PARAMETER ( DMAS2R = DAS2R / 1D3 ) * Arc seconds in a full circle DOUBLE PRECISION TURNAS PARAMETER ( TURNAS = 1296000D0 ) * Mean longitude of the ascending node of the Moon. OM = MOD ( 450160.398036D0 -6962890.5431D0*T, TURNAS ) * DAS2R Current implemention in astronomia is from: PJ Naughter (Web: www.naughter.com, Email: [email protected]) Look in nutation.py for calculation of omega _ko = (d_to_r(125.04452), d_to_r( -1934.136261), d_to_r( 0.0020708), d_to_r( 1.0/450000)) Though the last term was left off... Will have to incorporate better... """ T = jd_to_jcent(jd) X = polynomial( (d_to_r(125.0445479), d_to_r(-1934.1362891), d_to_r(0.0020754), d_to_r(1.0 / 467441.0), d_to_r(1.0 / 60616000.0)), T) return modpi2(X)
def mean_longitude_perigee(self, jd): """Return mean longitude of solar perigee. Parameters: jd : Julian Day in dynamical time Returns: Longitude of solar perigee in radians """ T = jd_to_jcent(jd) X = polynomial((1012395.0, 6189.03, 1.63, 0.012), (T + 1)) / 3600.0 X = d_to_r(X) X = modpi2(X) return X
def sidereal_time_greenwich(jd): """Return the mean sidereal time at Greenwich. The Julian Day number must represent Universal Time. Parameters: jd : Julian Day number Return: sidereal time in radians (2pi radians = 24 hrs) """ T = jd_to_jcent(jd) T2 = T * T T3 = T2 * T theta0 = 280.46061837 + 360.98564736629*(jd - 2451545.0) + 0.000387933*T2 - T3/38710000 result = d_to_r(theta0) return modpi2(result)
def sidereal_time_greenwich(julian_day): """Return the mean sidereal time at Greenwich. The Julian Day number must represent Universal Time. Arguments: - `julian_day` : (int) Julian Day number Returns: - sidereal time in radians : (float) 2pi radians = 24 hours """ T = jd_to_jcent(julian_day) T2 = T * T T3 = T2 * T theta0 = 280.46061837 + 360.98564736629 * (julian_day - 2451545.0) + 0.000387933 * T2 - T3 / 38710000 result = d_to_r(theta0) return modpi2(result)
def mean_longitude_perigee(self, jd): """Return mean longitude of solar perigee. Arguments: - `jd` : Julian Day in dynamical time Returns: - Longitude of solar perigee in radians """ jd = np.atleast_1d(jd) T = jd_to_jcent(jd) X = polynomial((1012395.0, 6189.03, 1.63, 0.012), (T + 1)) / 3600.0 X = d_to_r(X) X = modpi2(X) return _scalar_if_one(X)
def sidereal_time_greenwich(jd): """Return the mean sidereal time at Greenwich. The Julian Day number must represent Universal Time. Parameters: jd : Julian Day number Return: sidereal time in radians (2pi radians = 24 hrs) """ T = jd_to_jcent(jd) T2 = T * T T3 = T2 * T theta0 = 280.46061837 + 360.98564736629 * ( jd - 2451545.0) + 0.000387933 * T2 - T3 / 38710000 result = d_to_r(theta0) return modpi2(result)
def mean_longitude_perigee(self, jd): """Return mean longitude of solar perigee. Arguments: - `jd` : Julian Day in dynamical time Returns: - Longitude of solar perigee in radians """ jd = np.atleast_1d(jd) T = jd_to_jcent(jd) X = polynomial((1012395.0, 6189.03, 1.63, 0.012), (T + 1))/3600.0 X = d_to_r(X) X = modpi2(X) return _scalar_if_one(X)
def _longitude(self, jd): """Return the geocentric ecliptic longitude in radians. """ from astronomia.nutation import nutation_in_longitude T = jd_to_jcent(jd) L1, D, M, M1, F, A1, A2, A3, E, E2 = _constants(T) lsum = 0.0 for tD, tM, tM1, tF, tl, tr in _tblLR: arg = tD * D + tM * M + tM1 * M1 + tF * F if abs(tM) == 1: tl *= E elif abs(tM) == 2: tl *= E2 lsum += tl * np.sin(arg) lsum += 3958 * np.sin(A1) + 1962 * np.sin(L1 - F) + 318 * np.sin(A2) nutinlong = nutation_in_longitude(jd) longitude = L1 + d_to_r(lsum / 1000000) + nutinlong return longitude
def mean_longitude_perigee(self, jd): """Return mean longitude of solar perigee. Parameters: jd : Julian Day in dynamical time Returns: Longitude of solar perigee in radians """ T = jd_to_jcent(jd) X = polynomial((1012395.0, 6189.03 , 1.63 , 0.012 ), (T + 1))/3600.0 X = d_to_r(X) X = modpi2(X) return X
def sidereal_time_greenwich(julian_day): """Return the mean sidereal time at Greenwich. The Julian Day number must represent Universal Time. Arguments: - `julian_day` : (int) Julian Day number Returns: - sidereal time in radians : (float) 2pi radians = 24 hours """ T = jd_to_jcent(julian_day) T2 = T * T T3 = T2 * T theta0 = 280.46061837 + \ 360.98564736629*(julian_day - 2451545.0) + \ 0.000387933*T2 - \ T3/38710000 result = d_to_r(theta0) return modpi2(result)
def _longitude(self, jd): """Return the geocentric ecliptic longitude in radians. """ from astronomia.nutation import nutation_in_longitude T = jd_to_jcent(jd) L1, D, M, M1, F, A1, A2, A3, E, E2 = _constants(T) lsum = 0.0 for tD, tM, tM1, tF, tl, tr in _tblLR: arg = tD * D + tM * M + tM1 * M1 + tF * F if abs(tM) == 1: tl *= E elif abs(tM) == 2: tl *= E2 lsum += tl * np.sin(arg) lsum += 3958*np.sin(A1) + 1962*np.sin(L1 - F) + 318*np.sin(A2) nutinlong = nutation_in_longitude(jd) longitude = L1 + d_to_r(lsum / 1000000) + nutinlong return longitude
def _longitude(self, jd): """Return the geocentric ecliptic longitude in radians. A subset of the logic in dimension3() """ T = jd_to_jcent(jd) L1, D, M, M1, F, A1, A2, A3, E, E2 = _constants(T) lsum = 0.0 for tD, tM, tM1, tF, tl, tr in _tblLR: arg = tD * D + tM * M + tM1 * M1 + tF * F if abs(tM) == 1: tl *= E elif abs(tM == 2): tl *= E2 lsum += tl * sin(arg) lsum += 3958 * sin(A1) + \ 1962 * sin(L1 - F) + \ 318 * sin(A2) longitude = L1 + d_to_r(lsum / 1000000) return longitude
def _longitude(self, jd): """Return the geocentric ecliptic longitude in radians. A subset of the logic in dimension3() """ T = jd_to_jcent(jd) L1, D, M, M1, F, A1, A2, A3, E, E2 = _constants(T) lsum = 0.0 for tD, tM, tM1, tF, tl, tr in _tblLR: arg = tD * D + tM * M +tM1 * M1 + tF * F if abs(tM) == 1: tl *= E elif abs(tM == 2): tl *= E2 lsum += tl * sin(arg) lsum += 3958 * sin(A1) + \ 1962 * sin(L1 - F) + \ 318 * sin(A2) longitude = L1 + d_to_r(lsum / 1000000) return longitude
def mean_longitude(self, jd): """Return mean longitude. Parameters: jd : Julian Day in dynamical time Returns: Longitude in radians """ T = jd_to_jcent(jd) # From astrolabe #X = polynomial((d_to_r(100.466457), d_to_r(36000.7698278), d_to_r(0.00030322), d_to_r(0.000000020)), T) # From AA, Naughter # Takes T/10.0 X = polynomial( (d_to_r(100.4664567), d_to_r(360007.6982779), d_to_r(0.03032028), d_to_r(1.0 / 49931), d_to_r(-1.0 / 15300), d_to_r( -1.0 / 2000000)), T / 10.0) X = modpi2(X + pi) return X
def dimension3(self, jd): """Return geocentric ecliptic longitude, latitude and radius. When we need all three dimensions it is more efficient to combine the calculations in one routine. Parameters: jd : Julian Day in dynamical time Returns: longitude in radians latitude in radians radius in km, Earth's center to Moon's center """ T = jd_to_jcent(jd) L1, D, M, M1, F, A1, A2, A3, E, E2 = _constants(T) # # longitude and radius # lsum = 0.0 rsum = 0.0 for tD, tM, tM1, tF, tl, tr in _tblLR: arg = tD * D + tM * M + tM1 * M1 + tF * F if abs(tM) == 1: tl *= E tr *= E elif abs(tM == 2): tl *= E2 tr *= E2 lsum += tl * sin(arg) rsum += tr * cos(arg) # # latitude # bsum = 0.0 for tD, tM, tM1, tF, tb in _tblB: arg = tD * D + tM * M + tM1 * M1 + tF * F if abs(tM) == 1: tb *= E elif abs(tM) == 2: tb *= E2 bsum += tb * sin(arg) lsum += 3958 * sin(A1) + \ 1962 * sin(L1 - F) + \ 318 * sin(A2) bsum += -2235 * sin(L1) + \ 382 * sin(A3) + \ 175 * sin(A1 - F) + \ 175 * sin(A1 + F) + \ 127 * sin(L1 - M1) - \ 115 * sin(L1 + M1) longitude = L1 + d_to_r(lsum / 1000000) latitude = d_to_r(bsum / 1000000) dist = 385000.56 + rsum / 1000 return longitude, latitude, dist
T = jd_to_jcent(jd) D, M, M1, F, omega = _constants(T) deltaEps = 0.0 for tD, tM, tM1, tF, tomega, tpsiK, tpsiT, tepsK, tepsT in _tbl: arg = D * tD + M * tM + M1 * tM1 + F * tF + omega * tomega deltaEps = deltaEps + (tepsK / 10000.0 + tepsT / 100000.0 * T) * np.cos(arg) deltaEps = deltaEps / 3600 deltaEps = d_to_r(deltaEps) return deltaEps # # Constant terms # _el0 = (d_to_r(dms_to_d(23, 26, 21.448)), d_to_r(dms_to_d(0, 0, -46.8150)), d_to_r(dms_to_d(0, 0, -0.00059)), d_to_r(dms_to_d(0, 0, 0.001813))) def obliquity(jd): """Return the mean obliquity of the ecliptic. Low precision, but good enough for most uses. [Meeus-1998: equation 22.2]. Accuracy is 1" over 2000 years and 10" over 4000 years. Arguments: - `jd` : Julian Day in dynamical time Returns: - obliquity, in radians
"winter": (1721414.39987, 365242.88257, -0.00769, -0.00933, -0.00006)} # # Meeus-1998 Table 27.B # _approx_3000 = { "spring": (2451623.80984, 365242.37404, 0.05169, -0.00411, -0.00057), "summer": (2451716.56767, 365241.62603, 0.00325, 0.00888, -0.00030), "autumn": (2451810.21715, 365242.01767, -0.11575, 0.00337, 0.00078), "winter": (2451900.05952, 365242.74049, -0.06223, -0.00823, 0.00032)} # # Meeus-1998 Table 27.C # _terms = [ (485, d_to_r(324.96), d_to_r( 1934.136)), (203, d_to_r(337.23), d_to_r( 32964.467)), (199, d_to_r(342.08), d_to_r( 20.186)), (182, d_to_r( 27.85), d_to_r(445267.112)), (156, d_to_r( 73.14), d_to_r( 45036.886)), (136, d_to_r(171.52), d_to_r( 22518.443)), ( 77, d_to_r(222.54), d_to_r( 65928.934)), ( 74, d_to_r(296.72), d_to_r( 3034.906)), ( 70, d_to_r(243.58), d_to_r( 9037.513)), ( 58, d_to_r(119.81), d_to_r( 33718.147)), ( 52, d_to_r(297.17), d_to_r( 150.678)), ( 50, d_to_r( 21.02), d_to_r( 2281.226)), ( 45, d_to_r(247.54), d_to_r( 29929.562)), ( 44, d_to_r(325.15), d_to_r( 31555.956)), ( 29, d_to_r( 60.93), d_to_r( 4443.417)), ( 18, d_to_r(155.12), d_to_r( 67555.328)),
(1, 1, 0, -1, 223), (1, 1, 0, 1, 223), (0, 1, -2, -1, -220), (2, 1, -1, -1, -220), (1, 0, 1, 1, -185), (2, -1, -2, -1, 181), (0, 1, 2, 1, -177), (4, 0, -2, -1, 176), (4, -1, -1, -1, 166), (1, 0, 1, -1, -164), (4, 0, 1, -1, 132), (1, 0, -1, -1, -119), (4, -1, 0, -1, 115), (2, -2, 0, 1, 107)) _kA1 = (d_to_r(119.75), d_to_r(131.849)) _kA2 = (d_to_r(53.09), d_to_r(479264.290)) _kA3 = (d_to_r(313.45), d_to_r(481266.484)) def _constants(T): """Calculate values required by several other functions""" L1 = modpi2(polynomial(kL1, T)) D = modpi2(polynomial(kD, T)) M = modpi2(polynomial(kM, T)) M1 = modpi2(polynomial(kM1, T)) F = modpi2(polynomial(kF, T)) A1 = modpi2(polynomial(_kA1, T)) A2 = modpi2(polynomial(_kA2, T)) A3 = modpi2(polynomial(_kA3, T))
def test_ecl_to_equ(self): ra, dec = ecl_to_equ(d_to_r(113.215630), d_to_r(6.684170), d_to_r(23.4392911)) self.assertAlmostEqual(r_to_d(ra), 116.328942, places=5) self.assertAlmostEqual(r_to_d(dec), 28.026183, places=6)
# T = jd_to_jcent(jd) D, M, M1, F, omega = _constants(T) deltaEps = 0.0 for tD, tM, tM1, tF, tomega, tpsiK, tpsiT, tepsK, tepsT in _tbl: arg = D*tD + M*tM + M1*tM1 + F*tF + omega*tomega deltaEps = deltaEps + (tepsK/10000.0 + tepsT/100000.0 * T) * np.cos(arg) deltaEps = deltaEps / 3600 deltaEps = d_to_r(deltaEps) return deltaEps # # Constant terms # _el0 = (d_to_r(dms_to_d(23, 26, 21.448)), d_to_r(dms_to_d(0, 0, -46.8150)), d_to_r(dms_to_d(0, 0, -0.00059)), d_to_r(dms_to_d(0, 0, 0.001813))) def obliquity(jd): """Return the mean obliquity of the ecliptic. Low precision, but good enough for most uses. [Meeus-1998: equation 22.2]. Accuracy is 1" over 2000 years and 10" over 4000 years. Arguments: - `jd` : Julian Day in dynamical time Returns:
def test_ell_to_geo(self): phi, theta, r = ell_to_geo(d_to_r(0), d_to_r(0), 10000) self.assertAlmostEqual(r_to_d(modpi2(phi)), 203.23542197) self.assertAlmostEqual(r_to_d(modpi2(theta)), 90.0) self.assertAlmostEqual(r, 0.0)
Returns: - longitude in radians - latitude in radians - radius in au """ L = self.dimension(jd, "L") B = self.dimension(jd, "B") R = self.dimension(jd, "R") return L, B, R # # Constant terms # _kL0 = (d_to_r(280.46646), d_to_r(36000.76983), d_to_r(0.0003032)) _kM = (d_to_r(357.5291092), d_to_r(35999.0502909), d_to_r(-0.0001536), d_to_r(1.0 / 24490000)) _kC = (d_to_r(1.914602), d_to_r(-0.004817), d_to_r(-0.000014)) _ck3 = d_to_r(0.019993) _ck4 = d_to_r(-0.000101) _ck5 = d_to_r(0.000289) def longitude_radius_low(jd): """Return geometric longitude and radius vector. Low precision. The longitude is accurate to 0.01 degree. The latitude should be presumed to be 0.0. [Meeus-1998: equations 25.2 through 25.5
} # # Meeus-1998 Table 27.B # _approx_3000 = { "spring": (2451623.80984, 365242.37404, 0.05169, -0.00411, -0.00057), "summer": (2451716.56767, 365241.62603, 0.00325, 0.00888, -0.00030), "autumn": (2451810.21715, 365242.01767, -0.11575, 0.00337, 0.00078), "winter": (2451900.05952, 365242.74049, -0.06223, -0.00823, 0.00032) } # # Meeus-1998 Table 27.C # _terms = [(485, d_to_r(324.96), d_to_r(1934.136)), (203, d_to_r(337.23), d_to_r(32964.467)), (199, d_to_r(342.08), d_to_r(20.186)), (182, d_to_r(27.85), d_to_r(445267.112)), (156, d_to_r(73.14), d_to_r(45036.886)), (136, d_to_r(171.52), d_to_r(22518.443)), (77, d_to_r(222.54), d_to_r(65928.934)), (74, d_to_r(296.72), d_to_r(3034.906)), (70, d_to_r(243.58), d_to_r(9037.513)), (58, d_to_r(119.81), d_to_r(33718.147)), (52, d_to_r(297.17), d_to_r(150.678)), (50, d_to_r(21.02), d_to_r(2281.226)), (45, d_to_r(247.54), d_to_r(29929.562)), (44, d_to_r(325.15), d_to_r(31555.956)), (29, d_to_r(60.93), d_to_r(4443.417)), (18, d_to_r(155.12), d_to_r(67555.328)),
def test_geocentric_planet(self): ra, dec = geocentric_planet(2448976.5, "Venus", d_to_r(dms_to_d(0, 0, 16.749)), d_to_r(23.439669), days_per_second) np.testing.assert_array_almost_equal(r_to_d(ra), r_to_d(hms_to_fday(21, 4, 41.454) * pi2), decimal=5) np.testing.assert_almost_equal(r_to_d(dec), dms_to_d(-18, 53, 16.84), decimal=5)
Returns: - longitude in radians - latitude in radians - radius in au """ L = self.dimension(jd, "L") B = self.dimension(jd, "B") R = self.dimension(jd, "R") return L, B, R # # Constant terms # _kL0 = (d_to_r(280.46646), d_to_r(36000.76983), d_to_r(0.0003032)) _kM = (d_to_r(357.5291092), d_to_r(35999.0502909), d_to_r(-0.0001536), d_to_r(1.0/24490000)) _kC = (d_to_r(1.914602), d_to_r(-0.004817), d_to_r(-0.000014)) _ck3 = d_to_r(0.019993) _ck4 = d_to_r(-0.000101) _ck5 = d_to_r(0.000289)
(-1, 0, 1, 0, 0, -4, 0, 0, 0), (-2, 1, 0, 0, 0, -4, 0, 0, 0), ( 1, 0, 0, 0, 0, -4, 0, 0, 0), ( 0, 0, 1, 2, 0, 3, 0, 0, 0), ( 0, 0, -2, 2, 2, -3, 0, 0, 0), (-1, -1, 1, 0, 0, -3, 0, 0, 0), ( 0, 1, 1, 0, 0, -3, 0, 0, 0), ( 0, -1, 1, 2, 2, -3, 0, 0, 0), ( 2, -1, -1, 2, 2, -3, 0, 0, 0), ( 0, 0, 3, 2, 2, -3, 0, 0, 0), ( 2, -1, 0, 2, 2, -3, 0, 0, 0)) # # Constant terms. # _kD = (d_to_r(297.85036), d_to_r(445267.111480), d_to_r(-0.0019142), d_to_r( 1.0/189474)) _kM = (d_to_r(357.52772), d_to_r( 35999.050340), d_to_r(-0.0001603), d_to_r(-1.0/300000)) _kM1 = (d_to_r(134.96298), d_to_r(477198.867398), d_to_r( 0.0086972), d_to_r( 1.0/ 56250)) _kF = (d_to_r( 93.27191), d_to_r(483202.017538), d_to_r(-0.0036825), d_to_r( 1.0/327270)) _ko = (d_to_r(125.04452), d_to_r( -1934.136261), d_to_r( 0.0020708), d_to_r( 1.0/450000)) def _constants(T): """Return some values needed for both nut_in_lon() and nut_in_obl()""" D = modpi2(polynomial(_kD, T)) M = modpi2(polynomial(_kM, T)) M1 = modpi2(polynomial(_kM1, T)) F = modpi2(polynomial(_kF, T)) omega = modpi2(polynomial(_ko, T)) return D, M, M1, F, omega
but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Astronomia; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """ """Useful constants terms. Don't change these unless you are moving to a new universe. """ from astronomia.util import d_to_r # # Constant terms. # kL1 = (d_to_r(218.3164477), d_to_r(481267.88123421), d_to_r(-0.0015786), d_to_r(1.0 / 538841), d_to_r(-1.0 / 65194000)) kD = (d_to_r(297.8501921), d_to_r(445267.1114034), d_to_r(-0.0018819), d_to_r(1.0 / 545868), d_to_r(-1.0 / 113065000)) kM = (d_to_r(357.5291092), d_to_r(35999.0502909), d_to_r(-0.0001536), d_to_r(1.0 / 24490000)) kM1 = (d_to_r(134.9633964), d_to_r(477198.8675055), d_to_r(0.0087414), d_to_r(1.0 / 69699), d_to_r(-1.0 / 14712000)) kF = (d_to_r(93.2720950), d_to_r(483202.0175233), d_to_r(-0.0036539), d_to_r(-1.0 / 3526000), d_to_r(1.0 / 863310000)) ko = (d_to_r(125.0445479), d_to_r(-1934.1362891), d_to_r(0.0020754), d_to_r(1.0 / 467441.0), d_to_r(1.0 / 60616000.0))
from astronomia.calendar import sidereal_time_greenwich from astronomia.constants import seconds_per_day, pi2, earth_equ_radius, \ standard_rst_altitude from astronomia.dynamical import deltaT_seconds from astronomia.util import d_to_r, interpolate_angle3, diff_angle, \ modpi2, interpolate3 from astronomia.coordinates import equ_to_horiz import astronomia.globals class Error(Exception): """local exception class""" pass _k1 = d_to_r(360.985647) def _riseset(jd, raList, decList, h0, delta, mode, longitude=astronomia.globals.longitude, latitude=astronomia.globals.latitude): # Private function since rise/set so similar THETA0 = sidereal_time_greenwich(jd) deltaT_days = deltaT_seconds(jd) / seconds_per_day cosH0 = (np.sin(h0) - np.sin(latitude)*np.sin(decList[1])) / ( np.cos(latitude)*np.cos(decList[1])) # # future: return some indicator when the object is circumpolar or always # below the horizon.
def test_equ_to_ecl(self): longitude, latitude = equ_to_ecl(d_to_r(116.328942), d_to_r(28.026183), d_to_r(23.4392911)) self.assertAlmostEqual(r_to_d(longitude), 113.215630, places=6) self.assertAlmostEqual(r_to_d(latitude), 6.684170, places=6)
from math import * from astronomia.calendar import sidereal_time_greenwich from astronomia.constants import seconds_per_day, pi2, earth_equ_radius, standard_rst_altitude from astronomia.dynamical import deltaT_seconds from astronomia.util import d_to_r, interpolate_angle3, diff_angle, r_to_d, modpi2, interpolate3, equ_to_horiz import astronomia.globals class Error(Exception): """local exception class""" pass _k1 = d_to_r(360.985647) def rise(jd, raList, decList, h0, delta): """Return the Julian Day of the rise time of an object. Parameters: jd : Julian Day number of the day in question, at 0 hr UT raList : a sequence of three right accension values, in radians, for (jd-1, jd, jd+1) decList : a sequence of three right declination values, in radians, for (jd-1, jd, jd+1) h0 : the standard altitude in radians delta : desired accuracy in days. Times less than one minute are infeasible for rise times because of atmospheric refraction.
Returns: - longitude in radians - latitude in radians - radius in au """ L = self.dimension(jd, planet, "L") B = self.dimension(jd, planet, "B") R = self.dimension(jd, planet, "R") return L, B, R # # Constant terms # _k0 = d_to_r(-1.397) _k1 = d_to_r(-0.00031) _k2 = d_to_r(dms_to_d(0, 0, -0.09033)) _k3 = d_to_r(dms_to_d(0, 0, 0.03916)) def vsop_to_fk5(jd, L, B): """Convert VSOP to FK5 coordinates. This is required only when using the full precision of the VSOP model. [Meeus-1998: pg 219] Arguments: - `jd` : Julian Day in dynamical time - `L` : longitude in radians - `B` : latitude in radians
(2, 1, -1, -1, -220), (1, 0, 1, 1, -185), (2, -1, -2, -1, 181), (0, 1, 2, 1, -177), (4, 0, -2, -1, 176), (4, -1, -1, -1, 166), (1, 0, 1, -1, -164), (4, 0, 1, -1, 132), (1, 0, -1, -1, -119), (4, -1, 0, -1, 115), (2, -2, 0, 1, 107)) # # Constant terms. # _kL1 = (d_to_r(218.3164477), d_to_r(481267.88123421), d_to_r(-0.0015786), d_to_r(1.0 / 538841), d_to_r(-1.0 / 65194000)) _kD = (d_to_r(297.8501921), d_to_r(445267.1114034), d_to_r(-0.0018819), d_to_r(1.0 / 545868), d_to_r(-1.0 / 113065000)) _kM = (d_to_r(357.5291092), d_to_r(35999.0502909), d_to_r(-0.0001536), d_to_r(1.0 / 24490000)) _kM1 = (d_to_r(134.9633964), d_to_r(477198.8675055), d_to_r(0.0087414), d_to_r(1.0 / 69699), d_to_r(-1.0 / 14712000)) _kF = (d_to_r(93.2720950), d_to_r(483202.0175233), d_to_r(-0.0036539), d_to_r(-1.0 / 3526000), d_to_r(1.0 / 863310000)) _kA1 = (d_to_r(119.75), d_to_r(131.849)) _kA2 = (d_to_r(53.09), d_to_r(479264.290)) _kA3 = (d_to_r(313.45), d_to_r(481266.484))
(2, 0, -2, 1, -451), (0, 0, 3, -1, 439), (2, 0, 2, 1, 422), (2, 0, -3, -1, 421), (2, 1, -1, 1, -366), (2, 1, 0, 1, -351), (4, 0, 0, 1, 331), (2, -1, 1, 1, 315), (2, -2, 0, -1, 302), (0, 0, 1, 3, -283), (2, 1, 1, -1, -229), (1, 1, 0, -1, 223), (1, 1, 0, 1, 223), (0, 1, -2, -1, -220), (2, 1, -1, -1, -220), (1, 0, 1, 1, -185), (2, -1, -2, -1, 181), (0, 1, 2, 1, -177), (4, 0, -2, -1, 176), (4, -1, -1, -1, 166), (1, 0, 1, -1, -164), (4, 0, 1, -1, 132), (1, 0, -1, -1, -119), (4, -1, 0, -1, 115), (2, -2, 0, 1, 107)) _kA1 = (d_to_r(119.75), d_to_r(131.849)) _kA2 = (d_to_r(53.09), d_to_r(479264.290)) _kA3 = (d_to_r(313.45), d_to_r(481266.484)) def _constants(T): """Calculate values required by several other functions""" L1 = modpi2(polynomial(kL1, T)) D = modpi2(polynomial(kD, T)) M = modpi2(polynomial(kM, T)) M1 = modpi2(polynomial(kM1, T)) F = modpi2(polynomial(kF, T)) A1 = modpi2(polynomial(_kA1, T)) A2 = modpi2(polynomial(_kA2, T)) A3 = modpi2(polynomial(_kA3, T))
You should have received a copy of the GNU General Public License along with Astronomia; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """ """Useful constants terms. Don't change these unless you are moving to a new universe. """ from astronomia.util import d_to_r # # Constant terms. # kL1 = (d_to_r(218.3164477), d_to_r(481267.88123421), d_to_r(-0.0015786), d_to_r(1.0/538841), d_to_r(-1.0/65194000)) kD = (d_to_r(297.8501921), d_to_r(445267.1114034), d_to_r(-0.0018819), d_to_r(1.0/545868), d_to_r(-1.0/113065000)) kM = (d_to_r(357.5291092), d_to_r(35999.0502909), d_to_r(-0.0001536), d_to_r(1.0/24490000)) kM1 = (d_to_r(134.9633964), d_to_r(477198.8675055),
(2, 1, -1, -1, -220), (1, 0, 1, 1, -185), (2, -1, -2, -1, 181), (0, 1, 2, 1, -177), (4, 0, -2, -1, 176), (4, -1, -1, -1, 166), (1, 0, 1, -1, -164), (4, 0, 1, -1, 132), (1, 0, -1, -1, -119), (4, -1, 0, -1, 115), (2, -2, 0, 1, 107)) # # Constant terms. # _kL1 = (d_to_r(218.3164477), d_to_r(481267.88123421), d_to_r(-0.0015786), d_to_r(1.0/538841), d_to_r(-1.0/65194000)) _kD = (d_to_r(297.8501921), d_to_r(445267.1114034), d_to_r(-0.0018819), d_to_r(1.0/545868), d_to_r(-1.0/113065000)) _kM = (d_to_r(357.5291092), d_to_r( 35999.0502909), d_to_r(-0.0001536), d_to_r(1.0/24490000)) _kM1 = (d_to_r(134.9633964), d_to_r(477198.8675055), d_to_r(0.0087414), d_to_r(1.0/69699), d_to_r(-1.0/14712000)) _kF = (d_to_r( 93.2720950), d_to_r(483202.0175233), d_to_r(-0.0036539), d_to_r(-1.0/3526000), d_to_r( 1.0/863310000)) _kA1 = (d_to_r(119.75), d_to_r( 131.849)) _kA2 = (d_to_r( 53.09), d_to_r(479264.290)) _kA3 = (d_to_r(313.45), d_to_r(481266.484)) def _constants(T): """Calculate values required by several other functions""" L1 = modpi2(polynomial(_kL1, T)) D = modpi2(polynomial(_kD, T)) M = modpi2(polynomial(_kM, T))