def right_ascension(tee, beta, lam):
"""Return right ascension at moment UT 'tee' of object at
latitude 'lam' and longitude 'beta'."""
varepsilon = obliquity(tee)
return arctan_degrees((sin_degrees(lam) * cos_degrees(varepsilon)) -
(tan_degrees(beta) * sin_degrees(varepsilon)),
cos_degrees(lam))
def declination(tee, beta, lam):
"""Return declination at moment UT tee of object at
longitude 'lam' and latitude 'beta'."""
varepsilon = obliquity(tee)
return arcsin_degrees((sin_degrees(beta) * cos_degrees(varepsilon)) +
(cos_degrees(beta) * sin_degrees(varepsilon) *
sin_degrees(lam)))
def sine_offset(self, local_time, alpha):
"""Return sine of angle between position of sun at
local time tee and when its depression is alpha at location, location.
Out of range when it does not occur."""
phi = self.latitude
tee_prime = self.universal_from_local(local_time)
delta = declination(tee_prime, mpf(0), solar_longitude(tee_prime))
return ((tan_degrees(phi) * tan_degrees(delta)) +
(sin_degrees(alpha) / (cos_degrees(delta) *
cos_degrees(phi))))
def visible_crescent(self, date):
"""Return S. K. Shaukat's criterion for likely
visibility of crescent moon on eve of date 'date',
at location 'location'."""
tee = self.universal_from_standard(self.dusk(date - 1, mpf(4.5)))
phase = lunar_phase(tee)
altitude = self.lunar_altitude(tee)
arc_of_light = arccos_degrees(cos_degrees(lunar_latitude(tee)) * cos_degrees(phase))
return ((MoonPhase.NEW < phase < MoonPhase.FIRST_QUARTER) and
(mpf(10.6) <= arc_of_light <= 90) and
(altitude > mpf(4.1)))
def direction(self, focus):
"""Return the angle (clockwise from North) to face focus when
standing in location, location. Subject to errors near focus and
its antipode."""
y = sin_degrees(focus.longitude - self.longitude)
x = ((cos_degrees(self.latitude) * tan_degrees(focus.latitude)) -
(sin_degrees(self.latitude) * cos_degrees(self.longitude - focus.longitude)))
if x == y == 0 or focus.latitude == 90:
return 0
elif focus.latitude == -90:
return 180
else:
return arctan_degrees(y, x)
def lunar_altitude(self, tee):
"""Return the geocentric altitude of moon at moment, tee,
at location, location, as a small positive/negative angle in degrees,
ignoring parallax and refraction. Adapted from 'Astronomical
Algorithms' by Jean Meeus, Willmann_Bell, Inc., 1998."""
lamb = lunar_longitude(tee)
beta = lunar_latitude(tee)
alpha =right_ascension(tee, beta, lamb)
delta = declination(tee, beta, lamb)
theta0 = sidereal_from_moment(tee)
cap_H = mod(theta0 + self.longitude - alpha, 360)
altitude = arcsin_degrees(
(sin_degrees(self.latitude) * sin_degrees(delta)) +
(cos_degrees(self.latitude) * cos_degrees(delta) * cos_degrees(cap_H)))
return mod(altitude + 180, 360) - 180
def equation_of_time(tee):
"""Return the equation of time (as fraction of day) for moment, tee.
Adapted from "Astronomical Algorithms" by Jean Meeus,
Willmann_Bell, Inc., 1991."""
c = julian_centuries(tee)
lamb = poly(c, [mpf(280.46645), mpf(36000.76983), mpf(0.0003032)])
anomaly = poly(
c,
[mpf(357.52910),
mpf(35999.05030),
mpf(-0.0001559),
mpf(-0.00000048)])
eccentricity = poly(
c, [mpf(0.016708617),
mpf(-0.000042037),
mpf(-0.0000001236)])
varepsilon = obliquity(tee)
y = pow(tan_degrees(varepsilon / 2), 2)
equation = (
(1 / 2 / pi) *
(y * sin_degrees(2 * lamb) + -2 * eccentricity * sin_degrees(anomaly) +
(4 * eccentricity * y * sin_degrees(anomaly) * cos_degrees(2 * lamb))
+ -0.5 * y * y * sin_degrees(4 * lamb) +
-1.25 * eccentricity * eccentricity * sin_degrees(2 * anomaly)))
return signum(equation) * min(abs(equation), Clock.days_from_hours(
mpf(12)))
def lunar_parallax(self, tee):
"""Return the parallax of moon at moment, tee, at location, location.
Adapted from "Astronomical Algorithms" by Jean Meeus,
Willmann_Bell, Inc., 1998."""
geo = self.lunar_altitude(tee)
Delta = lunar_distance(tee)
alt = 6378140 / Delta
arg = alt * cos_degrees(geo)
return arcsin_degrees(arg)
def precession(tee):
"""Return the precession at moment tee using 0,0 as J2000 coordinates.
Adapted from "Astronomical Algorithms" by Jean Meeus,
Willmann-Bell, Inc., 1991."""
c = julian_centuries(tee)
eta = poly(
c, [0, secs(mpf(47.0029)),
secs(mpf(-0.03302)),
secs(mpf(0.000060))]) % 360
cap_P = poly(c,
[mpf(174.876384),
secs(mpf(-869.8089)),
secs(mpf(0.03536))]) % 360
p = poly(
c,
[0, secs(mpf(5029.0966)),
secs(mpf(1.11113)),
secs(mpf(0.000006))]) % 360
cap_A = cos_degrees(eta) * sin_degrees(cap_P)
cap_B = cos_degrees(cap_P)
arg = arctan_degrees(cap_A, cap_B)
return (p + cap_P - arg) % 360
def lunar_distance(tee):
"""Return the distance to moon (in meters) at moment, tee.
Adapted from "Astronomical Algorithms" by Jean Meeus,
Willmann_Bell, Inc., 2nd ed."""
c = julian_centuries(tee)
cap_D = lunar_elongation(c)
cap_M = solar_anomaly(c)
cap_M_prime = lunar_anomaly(c)
cap_F = moon_node(c)
cap_E = poly(c, [1, mpf(-0.002516), mpf(-0.0000074)])
args_lunar_elongation = \
[0, 2, 2, 0, 0, 0, 2, 2, 2, 2, 0, 1, 0, 2, 0, 0, 4, 0, 4, 2, 2, 1,
1, 2, 2, 4, 2, 0, 2, 2, 1, 2, 0, 0, 2, 2, 2, 4, 0, 3, 2, 4, 0, 2,
2, 2, 4, 0, 4, 1, 2, 0, 1, 3, 4, 2, 0, 1, 2, 2,]
args_solar_anomaly = \
[0, 0, 0, 0, 1, 0, 0, -1, 0, -1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1,
0, 1, -1, 0, 0, 0, 1, 0, -1, 0, -2, 1, 2, -2, 0, 0, -1, 0, 0, 1,
-1, 2, 2, 1, -1, 0, 0, -1, 0, 1, 0, 1, 0, 0, -1, 2, 1, 0, 0]
args_lunar_anomaly = \
[1, -1, 0, 2, 0, 0, -2, -1, 1, 0, -1, 0, 1, 0, 1, 1, -1, 3, -2,
-1, 0, -1, 0, 1, 2, 0, -3, -2, -1, -2, 1, 0, 2, 0, -1, 1, 0,
-1, 2, -1, 1, -2, -1, -1, -2, 0, 1, 4, 0, -2, 0, 2, 1, -2, -3,
2, 1, -1, 3, -1]
args_moon_node = \
[0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, -2, 2, -2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, -2, 2, 0, 2, 0, 0, 0, 0,
0, 0, -2, 0, 0, 0, 0, -2, -2, 0, 0, 0, 0, 0, 0, 0, -2]
cosine_coefficients = \
[-20905355, -3699111, -2955968, -569925, 48888, -3149,
246158, -152138, -170733, -204586, -129620, 108743,
104755, 10321, 0, 79661, -34782, -23210, -21636, 24208,
30824, -8379, -16675, -12831, -10445, -11650, 14403,
-7003, 0, 10056, 6322, -9884, 5751, 0, -4950, 4130, 0,
-3958, 0, 3258, 2616, -1897, -2117, 2354, 0, 0, -1423,
-1117, -1571, -1739, 0, -4421, 0, 0, 0, 0, 1165, 0, 0,
8752]
correction = sigma([
cosine_coefficients, args_lunar_elongation, args_solar_anomaly,
args_lunar_anomaly, args_moon_node
], lambda v, w, x, y, z: (v * pow(cap_E, abs(x)) * cos_degrees(
(w * cap_D) + (x * cap_M) + (y * cap_M_prime) + (z * cap_F))))
return 385000560 + correction
def aberration(tee):
"""Return the aberration at moment, tee."""
c = julian_centuries(tee)
return (
(mpf(0.0000974) * cos_degrees(mpf(177.63) + mpf(35999.01848) * c)) -
mpf(0.005575))
