def declination(cls, tee, beta, lam):
"""Return declination at moment UT tee of object at
longitude 'lam' and latitude 'beta'."""
varepsilon = cls.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 = Astro.declination(tee_prime, mpf(0), Solar.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.lunar_phase(tee)
altitude = self.lunar_altitude(tee)
arc_of_light = arccos_degrees(cos_degrees(Lunar.lunar_latitude(tee)) * cos_degrees(phase))
return ((Lunar.NEW < phase < Lunar.FIRST_QUARTER) and
(mpf(10.6) <= arc_of_light <= 90) and
(altitude > mpf(4.1)))
def precession(cls, 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 = cls.julian_centuries(tee)
eta = mod(poly(c, [0, secs(mpf(47.0029)), secs(mpf(-0.03302)), secs(mpf(0.000060))]), 360)
cap_P = mod(poly(c, [mpf(174.876384), secs(mpf(-869.8089)), secs(mpf(0.03536))]), 360)
p = mod(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 mod(p + cap_P - arg, 360)
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.lunar_longitude(tee)
beta = Lunar.lunar_latitude(tee)
alpha = Astro.right_ascension(tee, beta, lamb)
delta = Astro.declination(tee, beta, lamb)
theta0 = Astro.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 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.lunar_distance(tee)
alt = 6378140 / Delta
arg = alt * cos_degrees(geo)
return arcsin_degrees(arg)
def lunar_distance(cls, tee):
"""Return the distance to moon (in meters) at moment, tee.
Adapted from "Astronomical Algorithms" by Jean Meeus,
Willmann_Bell, Inc., 2nd ed."""
c = cls.julian_centuries(tee)
cap_D = cls.lunar_elongation(c)
cap_M = cls.solar_anomaly(c)
cap_M_prime = cls.lunar_anomaly(c)
cap_F = cls.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 equation_of_time(cls, 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 = cls.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 = cls.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 aberration(cls, tee):
"""Return the aberration at moment, tee."""
c = cls.julian_centuries(tee)
return ((mpf(0.0000974) *
cos_degrees(mpf(177.63) + mpf(35999.01848) * c)) -
mpf(0.005575))
def right_ascension(cls, tee, beta, lam):
"""Return right ascension at moment UT 'tee' of object at
latitude 'lam' and longitude 'beta'."""
varepsilon = cls.obliquity(tee)
return arctan_degrees((sin_degrees(lam) * cos_degrees(varepsilon)) - (tan_degrees(beta) * sin_degrees(varepsilon)), cos_degrees(lam))