8823 lines
337 KiB
C
8823 lines
337 KiB
C
/*
|
|
Astronomy Engine for C/C++.
|
|
https://github.com/cosinekitty/astronomy
|
|
|
|
MIT License
|
|
|
|
Copyright (c) 2019-2020 Don Cross <cosinekitty@gmail.com>
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in all
|
|
copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
SOFTWARE.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
#include <math.h>
|
|
#include "astronomy.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/** @cond DOXYGEN_SKIP */
|
|
#define PI 3.14159265358979323846
|
|
|
|
typedef struct
|
|
{
|
|
double x;
|
|
double y;
|
|
double z;
|
|
}
|
|
terse_vector_t;
|
|
|
|
static const terse_vector_t VecZero;
|
|
|
|
static terse_vector_t VecAdd(terse_vector_t a, terse_vector_t b)
|
|
{
|
|
terse_vector_t c;
|
|
c.x = a.x + b.x;
|
|
c.y = a.y + b.y;
|
|
c.z = a.z + b.z;
|
|
return c;
|
|
}
|
|
|
|
static terse_vector_t VecSub(terse_vector_t a, terse_vector_t b)
|
|
{
|
|
terse_vector_t c;
|
|
c.x = a.x - b.x;
|
|
c.y = a.y - b.y;
|
|
c.z = a.z - b.z;
|
|
return c;
|
|
}
|
|
|
|
static void VecIncr(terse_vector_t *target, terse_vector_t source)
|
|
{
|
|
target->x += source.x;
|
|
target->y += source.y;
|
|
target->z += source.z;
|
|
}
|
|
|
|
static void VecDecr(terse_vector_t *target, terse_vector_t source)
|
|
{
|
|
target->x -= source.x;
|
|
target->y -= source.y;
|
|
target->z -= source.z;
|
|
}
|
|
|
|
static terse_vector_t VecMul(double s, terse_vector_t v)
|
|
{
|
|
terse_vector_t p;
|
|
p.x = s * v.x;
|
|
p.y = s * v.y;
|
|
p.z = s * v.z;
|
|
return p;
|
|
}
|
|
|
|
static void VecScale(terse_vector_t *target, double scalar)
|
|
{
|
|
target->x *= scalar;
|
|
target->y *= scalar;
|
|
target->z *= scalar;
|
|
}
|
|
|
|
static terse_vector_t VecRamp(terse_vector_t a, terse_vector_t b, double ramp)
|
|
{
|
|
terse_vector_t c;
|
|
c.x = (1-ramp)*a.x + ramp*b.x;
|
|
c.y = (1-ramp)*a.y + ramp*b.y;
|
|
c.z = (1-ramp)*a.z + ramp*b.z;
|
|
return c;
|
|
}
|
|
|
|
static terse_vector_t VecMean(terse_vector_t a, terse_vector_t b)
|
|
{
|
|
terse_vector_t c;
|
|
c.x = (a.x + b.x) / 2;
|
|
c.y = (a.y + b.y) / 2;
|
|
c.z = (a.z + b.z) / 2;
|
|
return c;
|
|
}
|
|
|
|
static astro_vector_t PublicVec(astro_time_t time, terse_vector_t terse)
|
|
{
|
|
astro_vector_t vector;
|
|
|
|
vector.status = ASTRO_SUCCESS;
|
|
vector.t = time;
|
|
vector.x = terse.x;
|
|
vector.y = terse.y;
|
|
vector.z = terse.z;
|
|
|
|
return vector;
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
double tt; /* Terrestrial Time in J2000 days */
|
|
terse_vector_t r; /* position [au] */
|
|
terse_vector_t v; /* velocity [au/day] */
|
|
}
|
|
body_state_t;
|
|
/** @endcond */
|
|
|
|
static const double DAYS_PER_TROPICAL_YEAR = 365.24217;
|
|
static const double DEG2RAD = 0.017453292519943296;
|
|
static const double RAD2DEG = 57.295779513082321;
|
|
static const double ASEC360 = 1296000.0;
|
|
static const double ASEC2RAD = 4.848136811095359935899141e-6;
|
|
static const double PI2 = 2.0 * PI;
|
|
static const double ARC = 3600.0 * 180.0 / PI; /* arcseconds per radian */
|
|
static const double C_AUDAY = 173.1446326846693; /* speed of light in AU/day */
|
|
static const double KM_PER_AU = 1.4959787069098932e+8;
|
|
static const double SECONDS_PER_DAY = 24.0 * 3600.0;
|
|
static const double SOLAR_DAYS_PER_SIDEREAL_DAY = 0.9972695717592592;
|
|
static const double MEAN_SYNODIC_MONTH = 29.530588; /* average number of days for Moon to return to the same phase */
|
|
static const double EARTH_ORBITAL_PERIOD = 365.256;
|
|
static const double NEPTUNE_ORBITAL_PERIOD = 60189.0;
|
|
static const double REFRACTION_NEAR_HORIZON = 34.0 / 60.0; /* degrees of refractive "lift" seen for objects near horizon */
|
|
|
|
static const double SUN_RADIUS_KM = 695700.0;
|
|
#define SUN_RADIUS_AU (SUN_RADIUS_KM / KM_PER_AU)
|
|
|
|
#define EARTH_FLATTENING 0.996647180302104
|
|
#define EARTH_EQUATORIAL_RADIUS_KM 6378.1366
|
|
#define EARTH_EQUATORIAL_RADIUS_AU (EARTH_EQUATORIAL_RADIUS_KM / KM_PER_AU)
|
|
#define EARTH_MEAN_RADIUS_KM 6371.0 /* mean radius of the Earth's geoid, without atmosphere */
|
|
#define EARTH_ATMOSPHERE_KM 88.0 /* effective atmosphere thickness for lunar eclipses */
|
|
#define EARTH_ECLIPSE_RADIUS_KM (EARTH_MEAN_RADIUS_KM + EARTH_ATMOSPHERE_KM)
|
|
/* Note: if we ever need Earth's polar radius, it is (EARTH_FLATTENING * EARTH_EQUATORIAL_RADIUS_KM) */
|
|
|
|
#define MOON_EQUATORIAL_RADIUS_KM 1738.1
|
|
#define MOON_MEAN_RADIUS_KM 1737.4
|
|
#define MOON_POLAR_RADIUS_KM 1736.0
|
|
#define MOON_EQUATORIAL_RADIUS_AU (MOON_EQUATORIAL_RADIUS_KM / KM_PER_AU)
|
|
|
|
static const double ASEC180 = 180.0 * 60.0 * 60.0; /* arcseconds per 180 degrees (or pi radians) */
|
|
static const double EARTH_MOON_MASS_RATIO = 81.30056;
|
|
|
|
/*
|
|
Masses of the Sun and outer planets, used for:
|
|
(1) Calculating the Solar System Barycenter
|
|
(2) Integrating the movement of Pluto
|
|
|
|
https://web.archive.org/web/20120220062549/http://iau-comm4.jpl.nasa.gov/de405iom/de405iom.pdf
|
|
|
|
Page 10 in the above document describes the constants used in the DE405 ephemeris.
|
|
The following are G*M values (gravity constant * mass) in [au^3 / day^2].
|
|
This side-steps issues of not knowing the exact values of G and masses M[i];
|
|
the products GM[i] are known extremely accurately.
|
|
*/
|
|
static const double SUN_GM = 0.2959122082855911e-03;
|
|
static const double JUPITER_GM = 0.2825345909524226e-06;
|
|
static const double SATURN_GM = 0.8459715185680659e-07;
|
|
static const double URANUS_GM = 0.1292024916781969e-07;
|
|
static const double NEPTUNE_GM = 0.1524358900784276e-07;
|
|
|
|
/** @cond DOXYGEN_SKIP */
|
|
#define ARRAYSIZE(x) (sizeof(x) / sizeof(x[0]))
|
|
#define AU_PER_PARSEC (ASEC180 / PI) /* exact definition of how many AU = one parsec */
|
|
#define Y2000_IN_MJD (T0 - MJD_BASIS)
|
|
/** @endcond */
|
|
|
|
static astro_ecliptic_t RotateEquatorialToEcliptic(const double pos[3], double obliq_radians);
|
|
static int QuadInterp(
|
|
double tm, double dt, double fa, double fm, double fb,
|
|
double *x, double *t, double *df_dt);
|
|
|
|
static double LongitudeOffset(double diff)
|
|
{
|
|
double offset = diff;
|
|
|
|
while (offset <= -180.0)
|
|
offset += 360.0;
|
|
|
|
while (offset > 180.0)
|
|
offset -= 360.0;
|
|
|
|
return offset;
|
|
}
|
|
|
|
static double NormalizeLongitude(double lon)
|
|
{
|
|
while (lon < 0.0)
|
|
lon += 360.0;
|
|
|
|
while (lon >= 360.0)
|
|
lon -= 360.0;
|
|
|
|
return lon;
|
|
}
|
|
|
|
/**
|
|
* @brief Calculates the length of the given vector.
|
|
*
|
|
* Calculates the non-negative length of the given vector.
|
|
* The length is expressed in the same units as the vector's components,
|
|
* usually astronomical units (AU).
|
|
*
|
|
* @param vector The vector whose length is to be calculated.
|
|
* @return The length of the vector.
|
|
*/
|
|
double Astronomy_VectorLength(astro_vector_t vector)
|
|
{
|
|
return sqrt(vector.x*vector.x + vector.y*vector.y + vector.z*vector.z);
|
|
}
|
|
|
|
/**
|
|
* @brief Finds the name of a celestial body.
|
|
* @param body The celestial body whose name is to be found.
|
|
* @return The English-language name of the celestial body, or "" if the body is not valid.
|
|
*/
|
|
const char *Astronomy_BodyName(astro_body_t body)
|
|
{
|
|
switch (body)
|
|
{
|
|
case BODY_MERCURY: return "Mercury";
|
|
case BODY_VENUS: return "Venus";
|
|
case BODY_EARTH: return "Earth";
|
|
case BODY_MARS: return "Mars";
|
|
case BODY_JUPITER: return "Jupiter";
|
|
case BODY_SATURN: return "Saturn";
|
|
case BODY_URANUS: return "Uranus";
|
|
case BODY_NEPTUNE: return "Neptune";
|
|
case BODY_PLUTO: return "Pluto";
|
|
case BODY_SUN: return "Sun";
|
|
case BODY_MOON: return "Moon";
|
|
case BODY_EMB: return "EMB";
|
|
case BODY_SSB: return "SSB";
|
|
default: return "";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the #astro_body_t value corresponding to the given English name.
|
|
* @param name One of the following strings: Sun, Moon, Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto, EMB, SSB.
|
|
* @return If `name` is one of the listed strings (case-sensitive), the returned value is the corresponding #astro_body_t value, otherwise it is `BODY_INVALID`.
|
|
*/
|
|
astro_body_t Astronomy_BodyCode(const char *name)
|
|
{
|
|
if (name != NULL)
|
|
{
|
|
if (!strcmp(name, "Mercury")) return BODY_MERCURY;
|
|
if (!strcmp(name, "Venus")) return BODY_VENUS;
|
|
if (!strcmp(name, "Earth")) return BODY_EARTH;
|
|
if (!strcmp(name, "Mars")) return BODY_MARS;
|
|
if (!strcmp(name, "Jupiter")) return BODY_JUPITER;
|
|
if (!strcmp(name, "Saturn")) return BODY_SATURN;
|
|
if (!strcmp(name, "Uranus")) return BODY_URANUS;
|
|
if (!strcmp(name, "Neptune")) return BODY_NEPTUNE;
|
|
if (!strcmp(name, "Pluto")) return BODY_PLUTO;
|
|
if (!strcmp(name, "Sun")) return BODY_SUN;
|
|
if (!strcmp(name, "Moon")) return BODY_MOON;
|
|
if (!strcmp(name, "EMB")) return BODY_EMB;
|
|
if (!strcmp(name, "SSB")) return BODY_SSB;
|
|
}
|
|
return BODY_INVALID;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns 1 for planets that are farther from the Sun than the Earth is, 0 otherwise.
|
|
*/
|
|
static int IsSuperiorPlanet(astro_body_t body)
|
|
{
|
|
switch (body)
|
|
{
|
|
case BODY_MARS:
|
|
case BODY_JUPITER:
|
|
case BODY_SATURN:
|
|
case BODY_URANUS:
|
|
case BODY_NEPTUNE:
|
|
case BODY_PLUTO:
|
|
return 1;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the number of days it takes for a planet to orbit the Sun.
|
|
*/
|
|
static double PlanetOrbitalPeriod(astro_body_t body)
|
|
{
|
|
switch (body)
|
|
{
|
|
case BODY_MERCURY: return 87.969;
|
|
case BODY_VENUS: return 224.701;
|
|
case BODY_EARTH: return EARTH_ORBITAL_PERIOD;
|
|
case BODY_MARS: return 686.980;
|
|
case BODY_JUPITER: return 4332.589;
|
|
case BODY_SATURN: return 10759.22;
|
|
case BODY_URANUS: return 30685.4;
|
|
case BODY_NEPTUNE: return NEPTUNE_ORBITAL_PERIOD;
|
|
case BODY_PLUTO: return 90560.0;
|
|
default: return 0.0; /* invalid body */
|
|
}
|
|
}
|
|
|
|
static void FatalError(const char *message)
|
|
{
|
|
fprintf(stderr, "FATAL: %s\n", message);
|
|
exit(1);
|
|
}
|
|
|
|
static astro_vector_t VecError(astro_status_t status, astro_time_t time)
|
|
{
|
|
astro_vector_t vec;
|
|
vec.x = vec.y = vec.z = NAN;
|
|
vec.t = time;
|
|
vec.status = status;
|
|
return vec;
|
|
}
|
|
|
|
static astro_spherical_t SphereError(astro_status_t status)
|
|
{
|
|
astro_spherical_t sphere;
|
|
sphere.status = status;
|
|
sphere.dist = sphere.lat = sphere.lon = NAN;
|
|
return sphere;
|
|
}
|
|
|
|
static astro_equatorial_t EquError(astro_status_t status)
|
|
{
|
|
astro_equatorial_t equ;
|
|
equ.ra = equ.dec = equ.dist = NAN;
|
|
equ.status = status;
|
|
return equ;
|
|
}
|
|
|
|
static astro_ecliptic_t EclError(astro_status_t status)
|
|
{
|
|
astro_ecliptic_t ecl;
|
|
ecl.status = status;
|
|
ecl.ex = ecl.ey = ecl.ez = ecl.elat = ecl.elon = NAN;
|
|
return ecl;
|
|
}
|
|
|
|
static astro_angle_result_t AngleError(astro_status_t status)
|
|
{
|
|
astro_angle_result_t result;
|
|
result.status = status;
|
|
result.angle = NAN;
|
|
return result;
|
|
}
|
|
|
|
static astro_func_result_t FuncError(astro_status_t status)
|
|
{
|
|
astro_func_result_t result;
|
|
result.status = status;
|
|
result.value = NAN;
|
|
return result;
|
|
}
|
|
|
|
static astro_time_t TimeError(void)
|
|
{
|
|
astro_time_t time;
|
|
time.tt = time.ut = time.eps = time.psi = NAN;
|
|
return time;
|
|
}
|
|
|
|
static astro_rotation_t RotationErr(astro_status_t status)
|
|
{
|
|
astro_rotation_t rotation;
|
|
int i, j;
|
|
|
|
rotation.status = status;
|
|
for (i=0; i<3; ++i)
|
|
for (j=0; j<3; ++j)
|
|
rotation.rot[i][j] = NAN;
|
|
|
|
return rotation;
|
|
}
|
|
|
|
static astro_moon_quarter_t MoonQuarterError(astro_status_t status)
|
|
{
|
|
astro_moon_quarter_t result;
|
|
result.status = status;
|
|
result.quarter = -1;
|
|
result.time = TimeError();
|
|
return result;
|
|
}
|
|
|
|
static astro_elongation_t ElongError(astro_status_t status)
|
|
{
|
|
astro_elongation_t result;
|
|
|
|
result.status = status;
|
|
result.elongation = NAN;
|
|
result.ecliptic_separation = NAN;
|
|
result.time = TimeError();
|
|
result.visibility = (astro_visibility_t)(-1);
|
|
|
|
return result;
|
|
}
|
|
|
|
static astro_hour_angle_t HourAngleError(astro_status_t status)
|
|
{
|
|
astro_hour_angle_t result;
|
|
|
|
result.status = status;
|
|
result.time = TimeError();
|
|
result.hor.altitude = result.hor.azimuth = result.hor.dec = result.hor.ra = NAN;
|
|
|
|
return result;
|
|
}
|
|
|
|
static astro_illum_t IllumError(astro_status_t status)
|
|
{
|
|
astro_illum_t result;
|
|
|
|
result.status = status;
|
|
result.time = TimeError();
|
|
result.mag = NAN;
|
|
result.phase_angle = NAN;
|
|
result.helio_dist = NAN;
|
|
result.ring_tilt = NAN;
|
|
|
|
return result;
|
|
}
|
|
|
|
static astro_apsis_t ApsisError(astro_status_t status)
|
|
{
|
|
astro_apsis_t result;
|
|
|
|
result.status = status;
|
|
result.time = TimeError();
|
|
result.kind = APSIS_INVALID;
|
|
result.dist_km = result.dist_au = NAN;
|
|
|
|
return result;
|
|
}
|
|
|
|
static astro_search_result_t SearchError(astro_status_t status)
|
|
{
|
|
astro_search_result_t result;
|
|
result.time = TimeError();
|
|
result.status = status;
|
|
return result;
|
|
}
|
|
|
|
static astro_constellation_t ConstelErr(astro_status_t status)
|
|
{
|
|
astro_constellation_t constel;
|
|
constel.status = status;
|
|
constel.symbol = constel.name = NULL;
|
|
constel.ra_1875 = constel.dec_1875 = NAN;
|
|
return constel;
|
|
}
|
|
|
|
static astro_transit_t TransitErr(astro_status_t status)
|
|
{
|
|
astro_transit_t transit;
|
|
transit.status = status;
|
|
transit.start = transit.peak = transit.finish = TimeError();
|
|
transit.separation = NAN;
|
|
return transit;
|
|
}
|
|
|
|
static astro_func_result_t SynodicPeriod(astro_body_t body)
|
|
{
|
|
double Tp; /* planet's orbital period in days */
|
|
astro_func_result_t result;
|
|
|
|
/* The Earth does not have a synodic period as seen from itself. */
|
|
if (body == BODY_EARTH)
|
|
return FuncError(ASTRO_EARTH_NOT_ALLOWED);
|
|
|
|
if (body == BODY_MOON)
|
|
{
|
|
result.status = ASTRO_SUCCESS;
|
|
result.value = MEAN_SYNODIC_MONTH;
|
|
return result;
|
|
}
|
|
|
|
Tp = PlanetOrbitalPeriod(body);
|
|
if (Tp <= 0.0)
|
|
return FuncError(ASTRO_INVALID_BODY);
|
|
|
|
result.status = ASTRO_SUCCESS;
|
|
result.value = fabs(EARTH_ORBITAL_PERIOD / (EARTH_ORBITAL_PERIOD/Tp - 1.0));
|
|
return result;
|
|
}
|
|
|
|
static astro_angle_result_t AngleBetween(astro_vector_t a, astro_vector_t b)
|
|
{
|
|
double r, dot;
|
|
astro_angle_result_t result;
|
|
|
|
r = Astronomy_VectorLength(a) * Astronomy_VectorLength(b);
|
|
if (r < 1.0e-8)
|
|
return AngleError(ASTRO_BAD_VECTOR);
|
|
|
|
dot = (a.x*b.x + a.y*b.y + a.z*b.z) / r;
|
|
|
|
if (dot <= -1.0)
|
|
result.angle = 180.0;
|
|
else if (dot >= +1.0)
|
|
result.angle = 0.0;
|
|
else
|
|
result.angle = RAD2DEG * acos(dot);
|
|
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @brief The default Delta T function used by Astronomy Engine.
|
|
*
|
|
* Espenak and Meeus use a series of piecewise polynomials to
|
|
* approximate DeltaT of the Earth in their "Five Millennium Canon of Solar Eclipses".
|
|
* See: https://eclipse.gsfc.nasa.gov/SEhelp/deltatpoly2004.html
|
|
* This is the default Delta T function used by Astronomy Engine.
|
|
*
|
|
* @param ut
|
|
* The floating point number of days since noon UTC on January 1, 2000.
|
|
*
|
|
* @returns
|
|
* The estimated difference TT-UT on the given date, expressed in seconds.
|
|
*/
|
|
double Astronomy_DeltaT_EspenakMeeus(double ut)
|
|
{
|
|
double y, u, u2, u3, u4, u5, u6, u7;
|
|
|
|
/*
|
|
Fred Espenak writes about Delta-T generically here:
|
|
https://eclipse.gsfc.nasa.gov/SEhelp/deltaT.html
|
|
https://eclipse.gsfc.nasa.gov/SEhelp/deltat2004.html
|
|
|
|
He provides polynomial approximations for distant years here:
|
|
https://eclipse.gsfc.nasa.gov/SEhelp/deltatpoly2004.html
|
|
|
|
They start with a year value 'y' such that y=2000 corresponds
|
|
to the UTC Date 15-January-2000. Convert difference in days
|
|
to mean tropical years.
|
|
*/
|
|
|
|
y = 2000 + ((ut - 14) / DAYS_PER_TROPICAL_YEAR);
|
|
|
|
if (y < -500)
|
|
{
|
|
u = (y - 1820) / 100;
|
|
return -20 + (32 * u*u);
|
|
}
|
|
if (y < 500)
|
|
{
|
|
u = y / 100;
|
|
u2 = u*u; u3 = u*u2; u4 = u2*u2; u5 = u2*u3; u6 = u3*u3;
|
|
return 10583.6 - 1014.41*u + 33.78311*u2 - 5.952053*u3 - 0.1798452*u4 + 0.022174192*u5 + 0.0090316521*u6;
|
|
}
|
|
if (y < 1600)
|
|
{
|
|
u = (y - 1000) / 100;
|
|
u2 = u*u; u3 = u*u2; u4 = u2*u2; u5 = u2*u3; u6 = u3*u3;
|
|
return 1574.2 - 556.01*u + 71.23472*u2 + 0.319781*u3 - 0.8503463*u4 - 0.005050998*u5 + 0.0083572073*u6;
|
|
}
|
|
if (y < 1700)
|
|
{
|
|
u = y - 1600;
|
|
u2 = u*u; u3 = u*u2;
|
|
return 120 - 0.9808*u - 0.01532*u2 + u3/7129.0;
|
|
}
|
|
if (y < 1800)
|
|
{
|
|
u = y - 1700;
|
|
u2 = u*u; u3 = u*u2; u4 = u2*u2;
|
|
return 8.83 + 0.1603*u - 0.0059285*u2 + 0.00013336*u3 - u4/1174000;
|
|
}
|
|
if (y < 1860)
|
|
{
|
|
u = y - 1800;
|
|
u2 = u*u; u3 = u*u2; u4 = u2*u2; u5 = u2*u3; u6 = u3*u3; u7 = u3*u4;
|
|
return 13.72 - 0.332447*u + 0.0068612*u2 + 0.0041116*u3 - 0.00037436*u4 + 0.0000121272*u5 - 0.0000001699*u6 + 0.000000000875*u7;
|
|
}
|
|
if (y < 1900)
|
|
{
|
|
u = y - 1860;
|
|
u2 = u*u; u3 = u*u2; u4 = u2*u2; u5 = u2*u3;
|
|
return 7.62 + 0.5737*u - 0.251754*u2 + 0.01680668*u3 - 0.0004473624*u4 + u5/233174;
|
|
}
|
|
if (y < 1920)
|
|
{
|
|
u = y - 1900;
|
|
u2 = u*u; u3 = u*u2; u4 = u2*u2;
|
|
return -2.79 + 1.494119*u - 0.0598939*u2 + 0.0061966*u3 - 0.000197*u4;
|
|
}
|
|
if (y < 1941)
|
|
{
|
|
u = y - 1920;
|
|
u2 = u*u; u3 = u*u2;
|
|
return 21.20 + 0.84493*u - 0.076100*u2 + 0.0020936*u3;
|
|
}
|
|
if (y < 1961)
|
|
{
|
|
u = y - 1950;
|
|
u2 = u*u; u3 = u*u2;
|
|
return 29.07 + 0.407*u - u2/233 + u3/2547;
|
|
}
|
|
if (y < 1986)
|
|
{
|
|
u = y - 1975;
|
|
u2 = u*u; u3 = u*u2;
|
|
return 45.45 + 1.067*u - u2/260 - u3/718;
|
|
}
|
|
if (y < 2005)
|
|
{
|
|
u = y - 2000;
|
|
u2 = u*u; u3 = u*u2; u4 = u2*u2; u5 = u2*u3;
|
|
return 63.86 + 0.3345*u - 0.060374*u2 + 0.0017275*u3 + 0.000651814*u4 + 0.00002373599*u5;
|
|
}
|
|
if (y < 2050)
|
|
{
|
|
u = y - 2000;
|
|
return 62.92 + 0.32217*u + 0.005589*u*u;
|
|
}
|
|
if (y < 2150)
|
|
{
|
|
u = (y-1820)/100;
|
|
return -20 + 32*u*u - 0.5628*(2150 - y);
|
|
}
|
|
|
|
/* all years after 2150 */
|
|
u = (y - 1820) / 100;
|
|
return -20 + (32 * u*u);
|
|
}
|
|
|
|
/**
|
|
* @brief A Delta T function that approximates the one used by the JPL Horizons tool.
|
|
*
|
|
* In order to support unit tests based on data generated by the JPL Horizons online
|
|
* tool, I had to reverse engineer their Delta T function by generating a table that
|
|
* contained it. The main difference between their tool and the Espenak/Meeus function
|
|
* is that they stop extrapolating the Earth's deceleration after the year 2017.
|
|
*
|
|
* @param ut
|
|
* The floating point number of days since noon UTC on January 1, 2000.
|
|
*
|
|
* @returns
|
|
* The estimated difference TT-UT on the given date, expressed in seconds.
|
|
*/
|
|
double Astronomy_DeltaT_JplHorizons(double ut)
|
|
{
|
|
if (ut > 17.0 * DAYS_PER_TROPICAL_YEAR)
|
|
ut = 17.0 * DAYS_PER_TROPICAL_YEAR;
|
|
|
|
return Astronomy_DeltaT_EspenakMeeus(ut);
|
|
}
|
|
|
|
static astro_deltat_func DeltaTFunc = Astronomy_DeltaT_EspenakMeeus;
|
|
|
|
/**
|
|
* @brief Changes the function Astronomy Engine uses to calculate Delta T.
|
|
*
|
|
* Most programs should not call this function. It is for advanced use cases only.
|
|
* By default, Astronomy Engine uses the function #Astronomy_DeltaT_EspenakMeeus
|
|
* to estimate changes in the Earth's rotation rate over time.
|
|
* However, for the sake of unit tests that compare calculations against
|
|
* external data sources that use alternative models for Delta T,
|
|
* it is sometimes useful to replace the Delta T model to match.
|
|
* This function allows replacing the Delta T model with any other
|
|
* desired model.
|
|
*
|
|
* @param func
|
|
* A pointer to a function to convert UT values to DeltaT values.
|
|
*/
|
|
void Astronomy_SetDeltaTFunction(astro_deltat_func func)
|
|
{
|
|
DeltaTFunc = func;
|
|
}
|
|
|
|
static double TerrestrialTime(double ut)
|
|
{
|
|
return ut + DeltaTFunc(ut)/86400.0;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Converts a J2000 day value to an #astro_time_t value.
|
|
*
|
|
* This function can be useful for reproducing an #astro_time_t structure
|
|
* from its `ut` field only.
|
|
*
|
|
* @param ut
|
|
* The floating point number of days since noon UTC on January 1, 2000.
|
|
*
|
|
* @returns
|
|
* An #astro_time_t value for the given `ut` value.
|
|
*/
|
|
astro_time_t Astronomy_TimeFromDays(double ut)
|
|
{
|
|
astro_time_t time;
|
|
time.ut = ut;
|
|
time.tt = TerrestrialTime(ut);
|
|
time.psi = time.eps = NAN;
|
|
return time;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the computer's current date and time in the form of an #astro_time_t.
|
|
*
|
|
* Uses the computer's system clock to find the current UTC date and time with 1-second granularity.
|
|
* Converts that date and time to an #astro_time_t value and returns the result.
|
|
* Callers can pass this value to other Astronomy Engine functions to calculate
|
|
* current observational conditions.
|
|
*/
|
|
astro_time_t Astronomy_CurrentTime(void)
|
|
{
|
|
astro_time_t t;
|
|
|
|
/* Get seconds since midnight January 1, 1970, divide to convert to days, */
|
|
/* then subtract to get days since noon on January 1, 2000. */
|
|
|
|
t.ut = (time(NULL) / SECONDS_PER_DAY) - 10957.5;
|
|
t.tt = TerrestrialTime(t.ut);
|
|
t.psi = t.eps = NAN;
|
|
return t;
|
|
}
|
|
|
|
/**
|
|
* @brief Creates an #astro_time_t value from a given calendar date and time.
|
|
*
|
|
* Given a UTC calendar date and time, calculates an #astro_time_t value that can
|
|
* be passed to other Astronomy Engine functions for performing various calculations
|
|
* relating to that date and time.
|
|
*
|
|
* It is the caller's responsibility to ensure that the parameter values are correct.
|
|
* The parameters are not checked for validity,
|
|
* and this function never returns any indication of an error.
|
|
* Invalid values, for example passing in February 31, may cause unexpected return values.
|
|
*
|
|
* @param year The UTC calendar year, e.g. 2019.
|
|
* @param month The UTC calendar month in the range 1..12.
|
|
* @param day The UTC calendar day in the range 1..31.
|
|
* @param hour The UTC hour of the day in the range 0..23.
|
|
* @param minute The UTC minute in the range 0..59.
|
|
* @param second The UTC floating-point second in the range [0, 60).
|
|
*
|
|
* @return An #astro_time_t value that represents the given calendar date and time.
|
|
*/
|
|
astro_time_t Astronomy_MakeTime(int year, int month, int day, int hour, int minute, double second)
|
|
{
|
|
astro_time_t time;
|
|
long int jd12h;
|
|
long int y2000;
|
|
|
|
/* This formula is adapted from NOVAS C 3.1 function julian_date() */
|
|
jd12h = (long) day - 32075L + 1461L * ((long) year + 4800L
|
|
+ ((long) month - 14L) / 12L) / 4L
|
|
+ 367L * ((long) month - 2L - ((long) month - 14L) / 12L * 12L)
|
|
/ 12L - 3L * (((long) year + 4900L + ((long) month - 14L) / 12L)
|
|
/ 100L) / 4L;
|
|
|
|
y2000 = jd12h - 2451545L;
|
|
|
|
time.ut = (double)y2000 - 0.5 + (hour / 24.0) + (minute / (24.0 * 60.0)) + (second / (24.0 * 3600.0));
|
|
time.tt = TerrestrialTime(time.ut);
|
|
time.psi = time.eps = NAN;
|
|
|
|
return time;
|
|
}
|
|
|
|
/**
|
|
* @brief Calculates the sum or difference of an #astro_time_t with a specified floating point number of days.
|
|
*
|
|
* Sometimes we need to adjust a given #astro_time_t value by a certain amount of time.
|
|
* This function adds the given real number of days in `days` to the date and time in `time`.
|
|
*
|
|
* More precisely, the result's Universal Time field `ut` is exactly adjusted by `days` and
|
|
* the Terrestrial Time field `tt` is adjusted correctly for the resulting UTC date and time,
|
|
* according to the historical and predictive Delta-T model provided by the
|
|
* [United States Naval Observatory](http://maia.usno.navy.mil/ser7/).
|
|
*
|
|
* The value stored in `time` will not be modified; it is passed by value.
|
|
*
|
|
* @param time A date and time for which to calculate an adjusted date and time.
|
|
* @param days A floating point number of days by which to adjust `time`. May be negative, 0, or positive.
|
|
* @return A date and time that is conceptually equal to `time + days`.
|
|
*/
|
|
astro_time_t Astronomy_AddDays(astro_time_t time, double days)
|
|
{
|
|
/*
|
|
This is slightly wrong, but the error is tiny.
|
|
We really should be adding to TT, not to UT.
|
|
But using TT would require creating an inverse function for DeltaT,
|
|
which would be quite a bit of extra calculation.
|
|
I estimate the error is in practice on the order of 10^(-7)
|
|
times the value of 'days'.
|
|
This is based on a typical drift of 1 second per year between UT and TT.
|
|
*/
|
|
|
|
astro_time_t sum;
|
|
|
|
sum.ut = time.ut + days;
|
|
sum.tt = TerrestrialTime(sum.ut);
|
|
sum.eps = sum.psi = NAN;
|
|
|
|
return sum;
|
|
}
|
|
|
|
/**
|
|
* @brief Creates an #astro_time_t value from a given calendar date and time.
|
|
*
|
|
* This function is similar to #Astronomy_MakeTime, only it receives a
|
|
* UTC calendar date and time in the form of an #astro_utc_t structure instead of
|
|
* as separate numeric parameters. Astronomy_TimeFromUtc is the inverse of
|
|
* #Astronomy_UtcFromTime.
|
|
*
|
|
* @param utc The UTC calendar date and time to be converted to #astro_time_t.
|
|
* @return A value that can be used for astronomical calculations for the given date and time.
|
|
*/
|
|
astro_time_t Astronomy_TimeFromUtc(astro_utc_t utc)
|
|
{
|
|
return Astronomy_MakeTime(utc.year, utc.month, utc.day, utc.hour, utc.minute, utc.second);
|
|
}
|
|
|
|
/**
|
|
* @brief Determines the calendar year, month, day, and time from an #astro_time_t value.
|
|
*
|
|
* After calculating the date and time of an astronomical event in the form of
|
|
* an #astro_time_t value, it is often useful to display the result in a human-readable
|
|
* form. This function converts the linear time scales in the `ut` field of #astro_time_t
|
|
* into a calendar date and time: year, month, day, hours, minutes, and seconds, expressed
|
|
* in UTC.
|
|
*
|
|
* @param time The astronomical time value to be converted to calendar date and time.
|
|
* @return A date and time broken out into conventional year, month, day, hour, minute, and second.
|
|
*/
|
|
astro_utc_t Astronomy_UtcFromTime(astro_time_t time)
|
|
{
|
|
/* Adapted from the NOVAS C 3.1 function cal_date() */
|
|
astro_utc_t utc;
|
|
long jd, k, m, n;
|
|
double djd, x;
|
|
|
|
djd = time.ut + 2451545.5;
|
|
jd = (long)djd;
|
|
|
|
x = 24.0 * fmod(djd, 1.0);
|
|
utc.hour = (int)x;
|
|
x = 60.0 * fmod(x, 1.0);
|
|
utc.minute = (int)x;
|
|
utc.second = 60.0 * fmod(x, 1.0);
|
|
|
|
k = jd + 68569L;
|
|
n = 4L * k / 146097L;
|
|
k = k - (146097L * n + 3L) / 4L;
|
|
m = 4000L * (k + 1L) / 1461001L;
|
|
k = k - 1461L * m / 4L + 31L;
|
|
|
|
utc.month = (int) (80L * k / 2447L);
|
|
utc.day = (int) (k - 2447L * (long)utc.month / 80L);
|
|
k = (long) utc.month / 11L;
|
|
|
|
utc.month = (int) ((long)utc.month + 2L - 12L * k);
|
|
utc.year = (int) (100L * (n - 49L) + m + k);
|
|
|
|
return utc;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Formats an #astro_time_t value as an ISO 8601 string.
|
|
*
|
|
* Given an #astro_time_t value `time`, formats it as an ISO 8601
|
|
* string to the resolution specified by the `format` parameter.
|
|
* The result is stored in the `text` buffer whose capacity in bytes
|
|
* is specified by `size`.
|
|
*
|
|
* @param time
|
|
* The date and time whose civil time `time.ut` is to be formatted as an ISO 8601 string.
|
|
* If the civil time is outside the year range 0000 to 9999, the function fails
|
|
* and returns `ASTRO_BAD_TIME`. Years prior to 1583 are treated as if they are
|
|
* using the modern Gregorian calendar, even when the Julian calendar was actually in effect.
|
|
*
|
|
* @param format
|
|
* Specifies the resolution to which the date and time should be formatted,
|
|
* as explained at #astro_time_format_t.
|
|
* If the value of `format` is not recognized, the function fails and
|
|
* returns `ASTRO_INVALID_PARAMETER`.
|
|
*
|
|
* @param text
|
|
* A pointer to a text buffer to receive the output.
|
|
* If `text` is `NULL`, this function returns `ASTRO_INVALID_PARAMETER`.
|
|
* If the function fails for any reason, and `text` is not `NULL`,
|
|
* and `size` is greater than 0, the `text` buffer is set to an empty string.
|
|
*
|
|
* @param size
|
|
* The size in bytes of the buffer pointed to by `text`. The buffer must
|
|
* be large enough to accomodate the output format selected by the
|
|
* `format` parameter, as specified at #astro_time_format_t.
|
|
* If `size` is too small to hold the string as specified by `format`,
|
|
* the `text` buffer is set to `""` (if possible)
|
|
* and the function returns `ASTRO_BUFFER_TOO_SMALL`.
|
|
* A buffer that is `TIME_TEXT_BYTES` (25) bytes or larger is always large enough for this function.
|
|
*
|
|
* @return `ASTRO_SUCCESS` on success; otherwise an error as described in the parameter notes.
|
|
*/
|
|
astro_status_t Astronomy_FormatTime(
|
|
astro_time_t time,
|
|
astro_time_format_t format,
|
|
char *text,
|
|
size_t size)
|
|
{
|
|
int nprinted;
|
|
double rounding;
|
|
size_t min_size;
|
|
astro_utc_t utc;
|
|
|
|
if (text == NULL)
|
|
return ASTRO_INVALID_PARAMETER;
|
|
|
|
if (size == 0)
|
|
return ASTRO_BUFFER_TOO_SMALL;
|
|
|
|
text[0] = '\0'; /* initialize to empty string, in case an error occurs */
|
|
|
|
/* Validate 'size' parameter and perform date/time rounding. */
|
|
switch (format)
|
|
{
|
|
case TIME_FORMAT_DAY:
|
|
min_size = 11; /* "2020-12-31" */
|
|
rounding = 0.0; /* no rounding */
|
|
break;
|
|
|
|
case TIME_FORMAT_MINUTE:
|
|
min_size = 18; /* "2020-12-31T15:47Z" */
|
|
rounding = 0.5 / (24.0 * 60.0); /* round to nearest minute */
|
|
break;
|
|
|
|
case TIME_FORMAT_SECOND:
|
|
min_size = 21; /* "2020-12-31T15:47:59Z" */
|
|
rounding = 0.5 / (24.0 * 3600.0); /* round to nearest second */
|
|
break;
|
|
|
|
case TIME_FORMAT_MILLI:
|
|
min_size = 25; /* "2020-12-31T15:47:59.123Z" */
|
|
rounding = 0.5 / (24.0 * 3600000.0); /* round to nearest millisecond */
|
|
break;
|
|
|
|
default:
|
|
return ASTRO_INVALID_PARAMETER;
|
|
}
|
|
|
|
/* Check for insufficient buffer size. */
|
|
if (size < min_size)
|
|
return ASTRO_BUFFER_TOO_SMALL;
|
|
|
|
/* Perform rounding. */
|
|
time.ut += rounding;
|
|
|
|
/* Convert linear J2000 days to Gregorian UTC date/time. */
|
|
utc = Astronomy_UtcFromTime(time);
|
|
|
|
/* We require the year to be formatted as a 4-digit non-negative integer. */
|
|
if (utc.year < 0 || utc.year > 9999)
|
|
return ASTRO_BAD_TIME;
|
|
|
|
/* Format the string. */
|
|
switch (format)
|
|
{
|
|
case TIME_FORMAT_DAY:
|
|
nprinted = snprintf(text, size, "%04d-%02d-%02d",
|
|
utc.year, utc.month, utc.day);
|
|
break;
|
|
|
|
case TIME_FORMAT_MINUTE:
|
|
nprinted = snprintf(text, size, "%04d-%02d-%02dT%02d:%02dZ",
|
|
utc.year, utc.month, utc.day,
|
|
utc.hour, utc.minute);
|
|
break;
|
|
|
|
case TIME_FORMAT_SECOND:
|
|
nprinted = snprintf(text, size, "%04d-%02d-%02dT%02d:%02d:%02.0lfZ",
|
|
utc.year, utc.month, utc.day,
|
|
utc.hour, utc.minute, floor(utc.second));
|
|
break;
|
|
|
|
case TIME_FORMAT_MILLI:
|
|
nprinted = snprintf(text, size, "%04d-%02d-%02dT%02d:%02d:%06.3lfZ",
|
|
utc.year, utc.month, utc.day,
|
|
utc.hour, utc.minute, floor(1000.0 * utc.second) / 1000.0);
|
|
break;
|
|
|
|
default:
|
|
/* We should have already failed for any unknown 'format' value. */
|
|
return ASTRO_INTERNAL_ERROR;
|
|
}
|
|
|
|
if (nprinted < 0)
|
|
return ASTRO_INTERNAL_ERROR; /* should not be possible for snprintf to return a negative number */
|
|
|
|
if (1+(int)nprinted != min_size)
|
|
return ASTRO_INTERNAL_ERROR; /* there must be a bug calculating min_size or formatting the string */
|
|
|
|
return ASTRO_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Creates an observer object that represents a location on or near the surface of the Earth.
|
|
*
|
|
* Some Astronomy Engine functions calculate values pertaining to an observer on the Earth.
|
|
* These functions require a value of type #astro_observer_t that represents the location
|
|
* of such an observer.
|
|
*
|
|
* @param latitude The geographic latitude of the observer in degrees north (positive) or south (negative) of the equator.
|
|
* @param longitude The geographic longitude of the observer in degrees east (positive) or west (negative) of the prime meridian at Greenwich, England.
|
|
* @param height The height of the observer in meters above mean sea level.
|
|
* @return An observer object that can be passed to astronomy functions that require a geographic location.
|
|
*/
|
|
astro_observer_t Astronomy_MakeObserver(double latitude, double longitude, double height)
|
|
{
|
|
astro_observer_t observer;
|
|
|
|
observer.latitude = latitude;
|
|
observer.longitude = longitude;
|
|
observer.height = height;
|
|
|
|
return observer;
|
|
}
|
|
|
|
static void iau2000b(astro_time_t *time)
|
|
{
|
|
/* Adapted from the NOVAS C 3.1 function of the same name. */
|
|
|
|
struct row_t
|
|
{
|
|
int nals[5];
|
|
double cls[6];
|
|
};
|
|
|
|
static const struct row_t row[77] =
|
|
{
|
|
|
|
{ { 0, 0, 0, 0, 1 }, { -172064161, -174666, 33386, 92052331, 9086, 15377 } },
|
|
{ { 0, 0, 2, -2, 2 }, { -13170906, -1675, -13696, 5730336, -3015, -4587 } },
|
|
{ { 0, 0, 2, 0, 2 }, { -2276413, -234, 2796, 978459, -485, 1374 } },
|
|
{ { 0, 0, 0, 0, 2 }, { 2074554, 207, -698, -897492, 470, -291 } },
|
|
{ { 0, 1, 0, 0, 0 }, { 1475877, -3633, 11817, 73871, -184, -1924 } },
|
|
{ { 0, 1, 2, -2, 2 }, { -516821, 1226, -524, 224386, -677, -174 } },
|
|
{ { 1, 0, 0, 0, 0 }, { 711159, 73, -872, -6750, 0, 358 } },
|
|
{ { 0, 0, 2, 0, 1 }, { -387298, -367, 380, 200728, 18, 318 } },
|
|
{ { 1, 0, 2, 0, 2 }, { -301461, -36, 816, 129025, -63, 367 } },
|
|
{ { 0, -1, 2, -2, 2 }, { 215829, -494, 111, -95929, 299, 132 } },
|
|
{ { 0, 0, 2, -2, 1 }, { 128227, 137, 181, -68982, -9, 39 } },
|
|
{ { -1, 0, 2, 0, 2 }, { 123457, 11, 19, -53311, 32, -4 } },
|
|
{ { -1, 0, 0, 2, 0 }, { 156994, 10, -168, -1235, 0, 82 } },
|
|
{ { 1, 0, 0, 0, 1 }, { 63110, 63, 27, -33228, 0, -9 } },
|
|
{ { -1, 0, 0, 0, 1 }, { -57976, -63, -189, 31429, 0, -75 } },
|
|
{ { -1, 0, 2, 2, 2 }, { -59641, -11, 149, 25543, -11, 66 } },
|
|
{ { 1, 0, 2, 0, 1 }, { -51613, -42, 129, 26366, 0, 78 } },
|
|
{ { -2, 0, 2, 0, 1 }, { 45893, 50, 31, -24236, -10, 20 } },
|
|
{ { 0, 0, 0, 2, 0 }, { 63384, 11, -150, -1220, 0, 29 } },
|
|
{ { 0, 0, 2, 2, 2 }, { -38571, -1, 158, 16452, -11, 68 } },
|
|
{ { 0, -2, 2, -2, 2 }, { 32481, 0, 0, -13870, 0, 0 } },
|
|
{ { -2, 0, 0, 2, 0 }, { -47722, 0, -18, 477, 0, -25 } },
|
|
{ { 2, 0, 2, 0, 2 }, { -31046, -1, 131, 13238, -11, 59 } },
|
|
{ { 1, 0, 2, -2, 2 }, { 28593, 0, -1, -12338, 10, -3 } },
|
|
{ { -1, 0, 2, 0, 1 }, { 20441, 21, 10, -10758, 0, -3 } },
|
|
{ { 2, 0, 0, 0, 0 }, { 29243, 0, -74, -609, 0, 13 } },
|
|
{ { 0, 0, 2, 0, 0 }, { 25887, 0, -66, -550, 0, 11 } },
|
|
{ { 0, 1, 0, 0, 1 }, { -14053, -25, 79, 8551, -2, -45 } },
|
|
{ { -1, 0, 0, 2, 1 }, { 15164, 10, 11, -8001, 0, -1 } },
|
|
{ { 0, 2, 2, -2, 2 }, { -15794, 72, -16, 6850, -42, -5 } },
|
|
{ { 0, 0, -2, 2, 0 }, { 21783, 0, 13, -167, 0, 13 } },
|
|
{ { 1, 0, 0, -2, 1 }, { -12873, -10, -37, 6953, 0, -14 } },
|
|
{ { 0, -1, 0, 0, 1 }, { -12654, 11, 63, 6415, 0, 26 } },
|
|
{ { -1, 0, 2, 2, 1 }, { -10204, 0, 25, 5222, 0, 15 } },
|
|
{ { 0, 2, 0, 0, 0 }, { 16707, -85, -10, 168, -1, 10 } },
|
|
{ { 1, 0, 2, 2, 2 }, { -7691, 0, 44, 3268, 0, 19 } },
|
|
{ { -2, 0, 2, 0, 0 }, { -11024, 0, -14, 104, 0, 2 } },
|
|
{ { 0, 1, 2, 0, 2 }, { 7566, -21, -11, -3250, 0, -5 } },
|
|
{ { 0, 0, 2, 2, 1 }, { -6637, -11, 25, 3353, 0, 14 } },
|
|
{ { 0, -1, 2, 0, 2 }, { -7141, 21, 8, 3070, 0, 4 } },
|
|
{ { 0, 0, 0, 2, 1 }, { -6302, -11, 2, 3272, 0, 4 } },
|
|
{ { 1, 0, 2, -2, 1 }, { 5800, 10, 2, -3045, 0, -1 } },
|
|
{ { 2, 0, 2, -2, 2 }, { 6443, 0, -7, -2768, 0, -4 } },
|
|
{ { -2, 0, 0, 2, 1 }, { -5774, -11, -15, 3041, 0, -5 } },
|
|
{ { 2, 0, 2, 0, 1 }, { -5350, 0, 21, 2695, 0, 12 } },
|
|
{ { 0, -1, 2, -2, 1 }, { -4752, -11, -3, 2719, 0, -3 } },
|
|
{ { 0, 0, 0, -2, 1 }, { -4940, -11, -21, 2720, 0, -9 } },
|
|
{ { -1, -1, 0, 2, 0 }, { 7350, 0, -8, -51, 0, 4 } },
|
|
{ { 2, 0, 0, -2, 1 }, { 4065, 0, 6, -2206, 0, 1 } },
|
|
{ { 1, 0, 0, 2, 0 }, { 6579, 0, -24, -199, 0, 2 } },
|
|
{ { 0, 1, 2, -2, 1 }, { 3579, 0, 5, -1900, 0, 1 } },
|
|
{ { 1, -1, 0, 0, 0 }, { 4725, 0, -6, -41, 0, 3 } },
|
|
{ { -2, 0, 2, 0, 2 }, { -3075, 0, -2, 1313, 0, -1 } },
|
|
{ { 3, 0, 2, 0, 2 }, { -2904, 0, 15, 1233, 0, 7 } },
|
|
{ { 0, -1, 0, 2, 0 }, { 4348, 0, -10, -81, 0, 2 } },
|
|
{ { 1, -1, 2, 0, 2 }, { -2878, 0, 8, 1232, 0, 4 } },
|
|
{ { 0, 0, 0, 1, 0 }, { -4230, 0, 5, -20, 0, -2 } },
|
|
{ { -1, -1, 2, 2, 2 }, { -2819, 0, 7, 1207, 0, 3 } },
|
|
{ { -1, 0, 2, 0, 0 }, { -4056, 0, 5, 40, 0, -2 } },
|
|
{ { 0, -1, 2, 2, 2 }, { -2647, 0, 11, 1129, 0, 5 } },
|
|
{ { -2, 0, 0, 0, 1 }, { -2294, 0, -10, 1266, 0, -4 } },
|
|
{ { 1, 1, 2, 0, 2 }, { 2481, 0, -7, -1062, 0, -3 } },
|
|
{ { 2, 0, 0, 0, 1 }, { 2179, 0, -2, -1129, 0, -2 } },
|
|
{ { -1, 1, 0, 1, 0 }, { 3276, 0, 1, -9, 0, 0 } },
|
|
{ { 1, 1, 0, 0, 0 }, { -3389, 0, 5, 35, 0, -2 } },
|
|
{ { 1, 0, 2, 0, 0 }, { 3339, 0, -13, -107, 0, 1 } },
|
|
{ { -1, 0, 2, -2, 1 }, { -1987, 0, -6, 1073, 0, -2 } },
|
|
{ { 1, 0, 0, 0, 2 }, { -1981, 0, 0, 854, 0, 0 } },
|
|
{ { -1, 0, 0, 1, 0 }, { 4026, 0, -353, -553, 0, -139 } },
|
|
{ { 0, 0, 2, 1, 2 }, { 1660, 0, -5, -710, 0, -2 } },
|
|
{ { -1, 0, 2, 4, 2 }, { -1521, 0, 9, 647, 0, 4 } },
|
|
{ { -1, 1, 0, 1, 1 }, { 1314, 0, 0, -700, 0, 0 } },
|
|
{ { 0, -2, 2, -2, 1 }, { -1283, 0, 0, 672, 0, 0 } },
|
|
{ { 1, 0, 2, 2, 1 }, { -1331, 0, 8, 663, 0, 4 } },
|
|
{ { -2, 0, 2, 2, 2 }, { 1383, 0, -2, -594, 0, -2 } },
|
|
{ { -1, 0, 0, 0, 2 }, { 1405, 0, 4, -610, 0, 2 } },
|
|
{ { 1, 1, 2, -2, 2 }, { 1290, 0, 0, -556, 0, 0 } }
|
|
|
|
};
|
|
|
|
double t, el, elp, f, d, om, arg, dp, de, sarg, carg;
|
|
int i;
|
|
|
|
if (isnan(time->psi))
|
|
{
|
|
t = time->tt / 36525;
|
|
el = fmod(485868.249036 + t * 1717915923.2178, ASEC360) * ASEC2RAD;
|
|
elp = fmod(1287104.79305 + t * 129596581.0481, ASEC360) * ASEC2RAD;
|
|
f = fmod(335779.526232 + t * 1739527262.8478, ASEC360) * ASEC2RAD;
|
|
d = fmod(1072260.70369 + t * 1602961601.2090, ASEC360) * ASEC2RAD;
|
|
om = fmod(450160.398036 - t * 6962890.5431, ASEC360) * ASEC2RAD;
|
|
dp = 0;
|
|
de = 0;
|
|
for (i=76; i >= 0; --i)
|
|
{
|
|
arg = fmod((row[i].nals[0]*el + row[i].nals[1]*elp + row[i].nals[2]*f + row[i].nals[3]*d + row[i].nals[4]*om), PI2);
|
|
sarg = sin(arg);
|
|
carg = cos(arg);
|
|
dp += (row[i].cls[0] + row[i].cls[1]*t) * sarg + row[i].cls[2]*carg;
|
|
de += (row[i].cls[3] + row[i].cls[4]*t) * carg + row[i].cls[5]*sarg;
|
|
}
|
|
|
|
time->psi = -0.000135 + (dp * 1.0e-7);
|
|
time->eps = +0.000388 + (de * 1.0e-7);
|
|
}
|
|
}
|
|
|
|
static double mean_obliq(double tt)
|
|
{
|
|
double t = tt / 36525.0;
|
|
double asec =
|
|
(((( - 0.0000000434 * t
|
|
- 0.000000576 ) * t
|
|
+ 0.00200340 ) * t
|
|
- 0.0001831 ) * t
|
|
- 46.836769 ) * t + 84381.406;
|
|
|
|
return asec / 3600.0;
|
|
}
|
|
|
|
/** @cond DOXYGEN_SKIP */
|
|
typedef struct
|
|
{
|
|
double tt;
|
|
double dpsi;
|
|
double deps;
|
|
double ee;
|
|
double mobl;
|
|
double tobl;
|
|
}
|
|
earth_tilt_t;
|
|
/** @endcond */
|
|
|
|
static earth_tilt_t e_tilt(astro_time_t *time)
|
|
{
|
|
earth_tilt_t et;
|
|
|
|
iau2000b(time);
|
|
et.dpsi = time->psi;
|
|
et.deps = time->eps;
|
|
et.mobl = mean_obliq(time->tt);
|
|
et.tobl = et.mobl + (et.deps / 3600.0);
|
|
et.tt = time->tt;
|
|
et.ee = et.dpsi * cos(et.mobl * DEG2RAD) / 15.0;
|
|
|
|
return et;
|
|
}
|
|
|
|
static void ecl2equ_vec(astro_time_t time, const double ecl[3], double equ[3])
|
|
{
|
|
double obl = mean_obliq(time.tt) * DEG2RAD;
|
|
double cos_obl = cos(obl);
|
|
double sin_obl = sin(obl);
|
|
|
|
equ[0] = ecl[0];
|
|
equ[1] = ecl[1]*cos_obl - ecl[2]*sin_obl;
|
|
equ[2] = ecl[1]*sin_obl + ecl[2]*cos_obl;
|
|
}
|
|
|
|
|
|
static astro_rotation_t precession_rot(double tt1, double tt2)
|
|
{
|
|
astro_rotation_t rotation;
|
|
double xx, yx, zx, xy, yy, zy, xz, yz, zz;
|
|
double t, psia, omegaa, chia, sa, ca, sb, cb, sc, cc, sd, cd;
|
|
double eps0 = 84381.406;
|
|
|
|
if ((tt1 != 0.0) && (tt2 != 0.0))
|
|
FatalError("precession_rot: one of (tt1, tt2) must be zero.");
|
|
|
|
t = (tt2 - tt1) / 36525;
|
|
if (tt2 == 0)
|
|
t = -t;
|
|
|
|
psia = (((((- 0.0000000951 * t
|
|
+ 0.000132851 ) * t
|
|
- 0.00114045 ) * t
|
|
- 1.0790069 ) * t
|
|
+ 5038.481507 ) * t);
|
|
|
|
omegaa = (((((+ 0.0000003337 * t
|
|
- 0.000000467 ) * t
|
|
- 0.00772503 ) * t
|
|
+ 0.0512623 ) * t
|
|
- 0.025754 ) * t + eps0);
|
|
|
|
chia = (((((- 0.0000000560 * t
|
|
+ 0.000170663 ) * t
|
|
- 0.00121197 ) * t
|
|
- 2.3814292 ) * t
|
|
+ 10.556403 ) * t);
|
|
|
|
eps0 = eps0 * ASEC2RAD;
|
|
psia = psia * ASEC2RAD;
|
|
omegaa = omegaa * ASEC2RAD;
|
|
chia = chia * ASEC2RAD;
|
|
|
|
sa = sin(eps0);
|
|
ca = cos(eps0);
|
|
sb = sin(-psia);
|
|
cb = cos(-psia);
|
|
sc = sin(-omegaa);
|
|
cc = cos(-omegaa);
|
|
sd = sin(chia);
|
|
cd = cos(chia);
|
|
|
|
xx = cd * cb - sb * sd * cc;
|
|
yx = cd * sb * ca + sd * cc * cb * ca - sa * sd * sc;
|
|
zx = cd * sb * sa + sd * cc * cb * sa + ca * sd * sc;
|
|
xy = -sd * cb - sb * cd * cc;
|
|
yy = -sd * sb * ca + cd * cc * cb * ca - sa * cd * sc;
|
|
zy = -sd * sb * sa + cd * cc * cb * sa + ca * cd * sc;
|
|
xz = sb * sc;
|
|
yz = -sc * cb * ca - sa * cc;
|
|
zz = -sc * cb * sa + cc * ca;
|
|
|
|
if (tt2 == 0.0)
|
|
{
|
|
/* Perform rotation from other epoch to J2000.0. */
|
|
rotation.rot[0][0] = xx;
|
|
rotation.rot[0][1] = yx;
|
|
rotation.rot[0][2] = zx;
|
|
rotation.rot[1][0] = xy;
|
|
rotation.rot[1][1] = yy;
|
|
rotation.rot[1][2] = zy;
|
|
rotation.rot[2][0] = xz;
|
|
rotation.rot[2][1] = yz;
|
|
rotation.rot[2][2] = zz;
|
|
}
|
|
else
|
|
{
|
|
/* Perform rotation from J2000.0 to other epoch. */
|
|
rotation.rot[0][0] = xx;
|
|
rotation.rot[0][1] = xy;
|
|
rotation.rot[0][2] = xz;
|
|
rotation.rot[1][0] = yx;
|
|
rotation.rot[1][1] = yy;
|
|
rotation.rot[1][2] = yz;
|
|
rotation.rot[2][0] = zx;
|
|
rotation.rot[2][1] = zy;
|
|
rotation.rot[2][2] = zz;
|
|
}
|
|
|
|
rotation.status = ASTRO_SUCCESS;
|
|
return rotation;
|
|
}
|
|
|
|
|
|
static void precession(double tt1, const double pos1[3], double tt2, double pos2[3])
|
|
{
|
|
astro_rotation_t r = precession_rot(tt1, tt2);
|
|
pos2[0] = r.rot[0][0]*pos1[0] + r.rot[1][0]*pos1[1] + r.rot[2][0]*pos1[2];
|
|
pos2[1] = r.rot[0][1]*pos1[0] + r.rot[1][1]*pos1[1] + r.rot[2][1]*pos1[2];
|
|
pos2[2] = r.rot[0][2]*pos1[0] + r.rot[1][2]*pos1[1] + r.rot[2][2]*pos1[2];
|
|
}
|
|
|
|
|
|
static astro_equatorial_t vector2radec(const double pos[3])
|
|
{
|
|
astro_equatorial_t equ;
|
|
double xyproj;
|
|
|
|
xyproj = pos[0]*pos[0] + pos[1]*pos[1];
|
|
equ.dist = sqrt(xyproj + pos[2]*pos[2]);
|
|
equ.status = ASTRO_SUCCESS;
|
|
if (xyproj == 0.0)
|
|
{
|
|
if (pos[2] == 0.0)
|
|
{
|
|
/* Indeterminate coordinates; pos vector has zero length. */
|
|
equ = EquError(ASTRO_BAD_VECTOR);
|
|
}
|
|
else if (pos[2] < 0)
|
|
{
|
|
equ.ra = 0.0;
|
|
equ.dec = -90.0;
|
|
}
|
|
else
|
|
{
|
|
equ.ra = 0.0;
|
|
equ.dec = +90.0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
equ.ra = atan2(pos[1], pos[0]) / (DEG2RAD * 15.0);
|
|
if (equ.ra < 0)
|
|
equ.ra += 24.0;
|
|
|
|
equ.dec = RAD2DEG * atan2(pos[2], sqrt(xyproj));
|
|
}
|
|
|
|
return equ;
|
|
}
|
|
|
|
|
|
static astro_rotation_t nutation_rot(astro_time_t *time, int direction)
|
|
{
|
|
astro_rotation_t rotation;
|
|
earth_tilt_t tilt = e_tilt(time);
|
|
double oblm = tilt.mobl * DEG2RAD;
|
|
double oblt = tilt.tobl * DEG2RAD;
|
|
double psi = tilt.dpsi * ASEC2RAD;
|
|
double cobm = cos(oblm);
|
|
double sobm = sin(oblm);
|
|
double cobt = cos(oblt);
|
|
double sobt = sin(oblt);
|
|
double cpsi = cos(psi);
|
|
double spsi = sin(psi);
|
|
|
|
double xx = cpsi;
|
|
double yx = -spsi * cobm;
|
|
double zx = -spsi * sobm;
|
|
double xy = spsi * cobt;
|
|
double yy = cpsi * cobm * cobt + sobm * sobt;
|
|
double zy = cpsi * sobm * cobt - cobm * sobt;
|
|
double xz = spsi * sobt;
|
|
double yz = cpsi * cobm * sobt - sobm * cobt;
|
|
double zz = cpsi * sobm * sobt + cobm * cobt;
|
|
|
|
if (direction == 0)
|
|
{
|
|
/* forward rotation */
|
|
rotation.rot[0][0] = xx;
|
|
rotation.rot[0][1] = xy;
|
|
rotation.rot[0][2] = xz;
|
|
rotation.rot[1][0] = yx;
|
|
rotation.rot[1][1] = yy;
|
|
rotation.rot[1][2] = yz;
|
|
rotation.rot[2][0] = zx;
|
|
rotation.rot[2][1] = zy;
|
|
rotation.rot[2][2] = zz;
|
|
}
|
|
else
|
|
{
|
|
/* inverse rotation */
|
|
rotation.rot[0][0] = xx;
|
|
rotation.rot[0][1] = yx;
|
|
rotation.rot[0][2] = zx;
|
|
rotation.rot[1][0] = xy;
|
|
rotation.rot[1][1] = yy;
|
|
rotation.rot[1][2] = zy;
|
|
rotation.rot[2][0] = xz;
|
|
rotation.rot[2][1] = yz;
|
|
rotation.rot[2][2] = zz;
|
|
}
|
|
|
|
rotation.status = ASTRO_SUCCESS;
|
|
return rotation;
|
|
}
|
|
|
|
static void nutation(astro_time_t *time, int direction, const double inpos[3], double outpos[3])
|
|
{
|
|
astro_rotation_t r = nutation_rot(time, direction);
|
|
outpos[0] = r.rot[0][0]*inpos[0] + r.rot[1][0]*inpos[1] + r.rot[2][0]*inpos[2];
|
|
outpos[1] = r.rot[0][1]*inpos[0] + r.rot[1][1]*inpos[1] + r.rot[2][1]*inpos[2];
|
|
outpos[2] = r.rot[0][2]*inpos[0] + r.rot[1][2]*inpos[1] + r.rot[2][2]*inpos[2];
|
|
}
|
|
|
|
static double era(double ut) /* Earth Rotation Angle */
|
|
{
|
|
double thet1 = 0.7790572732640 + 0.00273781191135448 * ut;
|
|
double thet3 = fmod(ut, 1.0);
|
|
double theta = 360.0 * fmod(thet1 + thet3, 1.0);
|
|
if (theta < 0.0)
|
|
theta += 360.0;
|
|
|
|
return theta;
|
|
}
|
|
|
|
static double sidereal_time(astro_time_t *time)
|
|
{
|
|
double t = time->tt / 36525.0;
|
|
double eqeq = 15.0 * e_tilt(time).ee; /* Replace with eqeq=0 to get GMST instead of GAST (if we ever need it) */
|
|
double theta = era(time->ut);
|
|
double st = (eqeq + 0.014506 +
|
|
(((( - 0.0000000368 * t
|
|
- 0.000029956 ) * t
|
|
- 0.00000044 ) * t
|
|
+ 1.3915817 ) * t
|
|
+ 4612.156534 ) * t);
|
|
|
|
double gst = fmod(st/3600.0 + theta, 360.0) / 15.0;
|
|
if (gst < 0.0)
|
|
gst += 24.0;
|
|
|
|
return gst;
|
|
}
|
|
|
|
static void terra(astro_observer_t observer, double st, double pos[3])
|
|
{
|
|
double df2 = EARTH_FLATTENING * EARTH_FLATTENING;
|
|
double phi = observer.latitude * DEG2RAD;
|
|
double sinphi = sin(phi);
|
|
double cosphi = cos(phi);
|
|
double c = 1.0 / sqrt(cosphi*cosphi + df2*sinphi*sinphi);
|
|
double s = df2 * c;
|
|
double ht_km = observer.height / 1000.0;
|
|
double ach = EARTH_EQUATORIAL_RADIUS_KM*c + ht_km;
|
|
double ash = EARTH_EQUATORIAL_RADIUS_KM*s + ht_km;
|
|
double stlocl = (15.0*st + observer.longitude) * DEG2RAD;
|
|
double sinst = sin(stlocl);
|
|
double cosst = cos(stlocl);
|
|
|
|
pos[0] = ach * cosphi * cosst / KM_PER_AU;
|
|
pos[1] = ach * cosphi * sinst / KM_PER_AU;
|
|
pos[2] = ash * sinphi / KM_PER_AU;
|
|
|
|
#if 0
|
|
/* If we ever need to calculate the observer's velocity vector, here is how NOVAS C 3.1 does it... */
|
|
static const double ANGVEL = 7.2921150e-5;
|
|
vel[0] = -ANGVEL * ach * cosphi * sinst * 86400.0;
|
|
vel[1] = +ANGVEL * ach * cosphi * cosst * 86400.0;
|
|
vel[2] = 0.0;
|
|
#endif
|
|
}
|
|
|
|
static void geo_pos(astro_time_t *time, astro_observer_t observer, double outpos[3])
|
|
{
|
|
double gast, pos1[3], pos2[3];
|
|
|
|
gast = sidereal_time(time);
|
|
terra(observer, gast, pos1);
|
|
nutation(time, -1, pos1, pos2);
|
|
precession(time->tt, pos2, 0.0, outpos);
|
|
}
|
|
|
|
static void spin(double angle, const double pos1[3], double vec2[3])
|
|
{
|
|
double angr = angle * DEG2RAD;
|
|
double cosang = cos(angr);
|
|
double sinang = sin(angr);
|
|
vec2[0] = +cosang*pos1[0] + sinang*pos1[1];
|
|
vec2[1] = -sinang*pos1[0] + cosang*pos1[1];
|
|
vec2[2] = pos1[2];
|
|
}
|
|
|
|
/*------------------ CalcMoon ------------------*/
|
|
|
|
/** @cond DOXYGEN_SKIP */
|
|
|
|
#define DECLARE_PASCAL_ARRAY_1(elemtype,name,xmin,xmax) \
|
|
elemtype name[(xmax)-(xmin)+1]
|
|
|
|
#define DECLARE_PASCAL_ARRAY_2(elemtype,name,xmin,xmax,ymin,ymax) \
|
|
elemtype name[(xmax)-(xmin)+1][(ymax)-(ymin)+1]
|
|
|
|
#define ACCESS_PASCAL_ARRAY_1(name,xmin,x) \
|
|
((name)[(x)-(xmin)])
|
|
|
|
#define ACCESS_PASCAL_ARRAY_2(name,xmin,ymin,x,y) \
|
|
((name)[(x)-(xmin)][(y)-(ymin)])
|
|
|
|
typedef struct
|
|
{
|
|
double t;
|
|
double dgam;
|
|
double dlam, n, gam1c, sinpi;
|
|
double l0, l, ls, f, d, s;
|
|
double dl0, dl, dls, df, dd, ds;
|
|
DECLARE_PASCAL_ARRAY_2(double,co,-6,6,1,4); /* ARRAY[-6..6,1..4] OF REAL */
|
|
DECLARE_PASCAL_ARRAY_2(double,si,-6,6,1,4); /* ARRAY[-6..6,1..4] OF REAL */
|
|
}
|
|
MoonContext;
|
|
|
|
#define T (ctx->t)
|
|
#define DGAM (ctx->dgam)
|
|
#define DLAM (ctx->dlam)
|
|
#define N (ctx->n)
|
|
#define GAM1C (ctx->gam1c)
|
|
#define SINPI (ctx->sinpi)
|
|
#define L0 (ctx->l0)
|
|
#define L (ctx->l)
|
|
#define LS (ctx->ls)
|
|
#define F (ctx->f)
|
|
#define D (ctx->d)
|
|
#define S (ctx->s)
|
|
#define DL0 (ctx->dl0)
|
|
#define DL (ctx->dl)
|
|
#define DLS (ctx->dls)
|
|
#define DF (ctx->df)
|
|
#define DD (ctx->dd)
|
|
#define DS (ctx->ds)
|
|
#define CO(x,y) ACCESS_PASCAL_ARRAY_2(ctx->co,-6,1,x,y)
|
|
#define SI(x,y) ACCESS_PASCAL_ARRAY_2(ctx->si,-6,1,x,y)
|
|
|
|
static double Frac(double x)
|
|
{
|
|
return x - floor(x);
|
|
}
|
|
|
|
static void AddThe(
|
|
double c1, double s1, double c2, double s2,
|
|
double *c, double *s)
|
|
{
|
|
*c = c1*c2 - s1*s2;
|
|
*s = s1*c2 + c1*s2;
|
|
}
|
|
|
|
static double Sine(double phi)
|
|
{
|
|
/* sine, of phi in revolutions, not radians */
|
|
return sin(PI2 * phi);
|
|
}
|
|
|
|
static void LongPeriodic(MoonContext *ctx)
|
|
{
|
|
double S1 = Sine(0.19833+0.05611*T);
|
|
double S2 = Sine(0.27869+0.04508*T);
|
|
double S3 = Sine(0.16827-0.36903*T);
|
|
double S4 = Sine(0.34734-5.37261*T);
|
|
double S5 = Sine(0.10498-5.37899*T);
|
|
double S6 = Sine(0.42681-0.41855*T);
|
|
double S7 = Sine(0.14943-5.37511*T);
|
|
|
|
DL0 = 0.84*S1+0.31*S2+14.27*S3+ 7.26*S4+ 0.28*S5+0.24*S6;
|
|
DL = 2.94*S1+0.31*S2+14.27*S3+ 9.34*S4+ 1.12*S5+0.83*S6;
|
|
DLS =-6.40*S1 -1.89*S6;
|
|
DF = 0.21*S1+0.31*S2+14.27*S3-88.70*S4-15.30*S5+0.24*S6-1.86*S7;
|
|
DD = DL0-DLS;
|
|
DGAM = -3332E-9 * Sine(0.59734-5.37261*T)
|
|
-539E-9 * Sine(0.35498-5.37899*T)
|
|
-64E-9 * Sine(0.39943-5.37511*T);
|
|
}
|
|
|
|
static void Init(MoonContext *ctx)
|
|
{
|
|
int I, J, MAX;
|
|
double T2, ARG, FAC;
|
|
|
|
T2 = T*T;
|
|
DLAM = 0;
|
|
DS = 0;
|
|
GAM1C = 0;
|
|
SINPI = 3422.7000;
|
|
LongPeriodic(ctx);
|
|
L0 = PI2*Frac(0.60643382+1336.85522467*T-0.00000313*T2) + DL0/ARC;
|
|
L = PI2*Frac(0.37489701+1325.55240982*T+0.00002565*T2) + DL /ARC;
|
|
LS = PI2*Frac(0.99312619+ 99.99735956*T-0.00000044*T2) + DLS/ARC;
|
|
F = PI2*Frac(0.25909118+1342.22782980*T-0.00000892*T2) + DF /ARC;
|
|
D = PI2*Frac(0.82736186+1236.85308708*T-0.00000397*T2) + DD /ARC;
|
|
for (I=1; I<=4; ++I)
|
|
{
|
|
switch(I)
|
|
{
|
|
case 1: ARG=L; MAX=4; FAC=1.000002208; break;
|
|
case 2: ARG=LS; MAX=3; FAC=0.997504612-0.002495388*T; break;
|
|
case 3: ARG=F; MAX=4; FAC=1.000002708+139.978*DGAM; break;
|
|
default: ARG=D; MAX=6; FAC=1.0; break;
|
|
}
|
|
CO(0,I) = 1.0;
|
|
CO(1,I) = cos(ARG)*FAC;
|
|
SI(0,I) = 0.0;
|
|
SI(1,I) = sin(ARG)*FAC;
|
|
for (J=2; J<=MAX; ++J)
|
|
AddThe(CO(J-1,I), SI(J-1,I), CO(1,I), SI(1,I), &CO(J,I), &SI(J,I));
|
|
|
|
for (J=1; J<=MAX; ++J)
|
|
{
|
|
CO(-J,I) = CO(J,I);
|
|
SI(-J,I) = -SI(J,I);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void Term(MoonContext *ctx, int p, int q, int r, int s, double *x, double *y)
|
|
{
|
|
int k;
|
|
DECLARE_PASCAL_ARRAY_1(int, i, 1, 4);
|
|
#define I(n) ACCESS_PASCAL_ARRAY_1(i,1,n)
|
|
|
|
I(1) = p;
|
|
I(2) = q;
|
|
I(3) = r;
|
|
I(4) = s;
|
|
*x = 1.0;
|
|
*y = 0.0;
|
|
|
|
for (k=1; k<=4; ++k)
|
|
if (I(k) != 0.0)
|
|
AddThe(*x, *y, CO(I(k), k), SI(I(k), k), x, y);
|
|
|
|
#undef I
|
|
}
|
|
|
|
static void AddSol(
|
|
MoonContext *ctx,
|
|
double coeffl,
|
|
double coeffs,
|
|
double coeffg,
|
|
double coeffp,
|
|
int p,
|
|
int q,
|
|
int r,
|
|
int s)
|
|
{
|
|
double x, y;
|
|
Term(ctx, p, q, r, s, &x, &y);
|
|
DLAM += coeffl*y;
|
|
DS += coeffs*y;
|
|
GAM1C += coeffg*x;
|
|
SINPI += coeffp*x;
|
|
}
|
|
|
|
#define ADDN(coeffn,p,q,r,s) ( Term(ctx, (p),(q),(r),(s),&x,&y), (N += (coeffn)*y) )
|
|
|
|
static void SolarN(MoonContext *ctx)
|
|
{
|
|
double x, y;
|
|
|
|
N = 0.0;
|
|
ADDN(-526.069, 0, 0,1,-2);
|
|
ADDN( -3.352, 0, 0,1,-4);
|
|
ADDN( +44.297,+1, 0,1,-2);
|
|
ADDN( -6.000,+1, 0,1,-4);
|
|
ADDN( +20.599,-1, 0,1, 0);
|
|
ADDN( -30.598,-1, 0,1,-2);
|
|
ADDN( -24.649,-2, 0,1, 0);
|
|
ADDN( -2.000,-2, 0,1,-2);
|
|
ADDN( -22.571, 0,+1,1,-2);
|
|
ADDN( +10.985, 0,-1,1,-2);
|
|
}
|
|
|
|
static void Planetary(MoonContext *ctx)
|
|
{
|
|
DLAM +=
|
|
+0.82*Sine(0.7736 -62.5512*T)+0.31*Sine(0.0466 -125.1025*T)
|
|
+0.35*Sine(0.5785 -25.1042*T)+0.66*Sine(0.4591+1335.8075*T)
|
|
+0.64*Sine(0.3130 -91.5680*T)+1.14*Sine(0.1480+1331.2898*T)
|
|
+0.21*Sine(0.5918+1056.5859*T)+0.44*Sine(0.5784+1322.8595*T)
|
|
+0.24*Sine(0.2275 -5.7374*T)+0.28*Sine(0.2965 +2.6929*T)
|
|
+0.33*Sine(0.3132 +6.3368*T);
|
|
}
|
|
|
|
int _CalcMoonCount; /* Undocumented global for performance tuning. */
|
|
|
|
static void CalcMoon(
|
|
double centuries_since_j2000,
|
|
double *geo_eclip_lon, /* (LAMBDA) equinox of date */
|
|
double *geo_eclip_lat, /* (BETA) equinox of date */
|
|
double *distance_au) /* (R) */
|
|
{
|
|
double lat_seconds;
|
|
MoonContext context;
|
|
MoonContext *ctx = &context; /* goofy, but makes macros work inside this function */
|
|
|
|
context.t = centuries_since_j2000;
|
|
Init(ctx);
|
|
|
|
AddSol(ctx, 13.9020, 14.0600, -0.0010, 0.2607, 0, 0, 0, 4);
|
|
AddSol(ctx, 0.4030, -4.0100, 0.3940, 0.0023, 0, 0, 0, 3);
|
|
AddSol(ctx, 2369.9120, 2373.3600, 0.6010, 28.2333, 0, 0, 0, 2);
|
|
AddSol(ctx, -125.1540, -112.7900, -0.7250, -0.9781, 0, 0, 0, 1);
|
|
AddSol(ctx, 1.9790, 6.9800, -0.4450, 0.0433, 1, 0, 0, 4);
|
|
AddSol(ctx, 191.9530, 192.7200, 0.0290, 3.0861, 1, 0, 0, 2);
|
|
AddSol(ctx, -8.4660, -13.5100, 0.4550, -0.1093, 1, 0, 0, 1);
|
|
AddSol(ctx, 22639.5000, 22609.0700, 0.0790, 186.5398, 1, 0, 0, 0);
|
|
AddSol(ctx, 18.6090, 3.5900, -0.0940, 0.0118, 1, 0, 0,-1);
|
|
AddSol(ctx, -4586.4650, -4578.1300, -0.0770, 34.3117, 1, 0, 0,-2);
|
|
AddSol(ctx, 3.2150, 5.4400, 0.1920, -0.0386, 1, 0, 0,-3);
|
|
AddSol(ctx, -38.4280, -38.6400, 0.0010, 0.6008, 1, 0, 0,-4);
|
|
AddSol(ctx, -0.3930, -1.4300, -0.0920, 0.0086, 1, 0, 0,-6);
|
|
AddSol(ctx, -0.2890, -1.5900, 0.1230, -0.0053, 0, 1, 0, 4);
|
|
AddSol(ctx, -24.4200, -25.1000, 0.0400, -0.3000, 0, 1, 0, 2);
|
|
AddSol(ctx, 18.0230, 17.9300, 0.0070, 0.1494, 0, 1, 0, 1);
|
|
AddSol(ctx, -668.1460, -126.9800, -1.3020, -0.3997, 0, 1, 0, 0);
|
|
AddSol(ctx, 0.5600, 0.3200, -0.0010, -0.0037, 0, 1, 0,-1);
|
|
AddSol(ctx, -165.1450, -165.0600, 0.0540, 1.9178, 0, 1, 0,-2);
|
|
AddSol(ctx, -1.8770, -6.4600, -0.4160, 0.0339, 0, 1, 0,-4);
|
|
AddSol(ctx, 0.2130, 1.0200, -0.0740, 0.0054, 2, 0, 0, 4);
|
|
AddSol(ctx, 14.3870, 14.7800, -0.0170, 0.2833, 2, 0, 0, 2);
|
|
AddSol(ctx, -0.5860, -1.2000, 0.0540, -0.0100, 2, 0, 0, 1);
|
|
AddSol(ctx, 769.0160, 767.9600, 0.1070, 10.1657, 2, 0, 0, 0);
|
|
AddSol(ctx, 1.7500, 2.0100, -0.0180, 0.0155, 2, 0, 0,-1);
|
|
AddSol(ctx, -211.6560, -152.5300, 5.6790, -0.3039, 2, 0, 0,-2);
|
|
AddSol(ctx, 1.2250, 0.9100, -0.0300, -0.0088, 2, 0, 0,-3);
|
|
AddSol(ctx, -30.7730, -34.0700, -0.3080, 0.3722, 2, 0, 0,-4);
|
|
AddSol(ctx, -0.5700, -1.4000, -0.0740, 0.0109, 2, 0, 0,-6);
|
|
AddSol(ctx, -2.9210, -11.7500, 0.7870, -0.0484, 1, 1, 0, 2);
|
|
AddSol(ctx, 1.2670, 1.5200, -0.0220, 0.0164, 1, 1, 0, 1);
|
|
AddSol(ctx, -109.6730, -115.1800, 0.4610, -0.9490, 1, 1, 0, 0);
|
|
AddSol(ctx, -205.9620, -182.3600, 2.0560, 1.4437, 1, 1, 0,-2);
|
|
AddSol(ctx, 0.2330, 0.3600, 0.0120, -0.0025, 1, 1, 0,-3);
|
|
AddSol(ctx, -4.3910, -9.6600, -0.4710, 0.0673, 1, 1, 0,-4);
|
|
AddSol(ctx, 0.2830, 1.5300, -0.1110, 0.0060, 1,-1, 0, 4);
|
|
AddSol(ctx, 14.5770, 31.7000, -1.5400, 0.2302, 1,-1, 0, 2);
|
|
AddSol(ctx, 147.6870, 138.7600, 0.6790, 1.1528, 1,-1, 0, 0);
|
|
AddSol(ctx, -1.0890, 0.5500, 0.0210, 0.0000, 1,-1, 0,-1);
|
|
AddSol(ctx, 28.4750, 23.5900, -0.4430, -0.2257, 1,-1, 0,-2);
|
|
AddSol(ctx, -0.2760, -0.3800, -0.0060, -0.0036, 1,-1, 0,-3);
|
|
AddSol(ctx, 0.6360, 2.2700, 0.1460, -0.0102, 1,-1, 0,-4);
|
|
AddSol(ctx, -0.1890, -1.6800, 0.1310, -0.0028, 0, 2, 0, 2);
|
|
AddSol(ctx, -7.4860, -0.6600, -0.0370, -0.0086, 0, 2, 0, 0);
|
|
AddSol(ctx, -8.0960, -16.3500, -0.7400, 0.0918, 0, 2, 0,-2);
|
|
AddSol(ctx, -5.7410, -0.0400, 0.0000, -0.0009, 0, 0, 2, 2);
|
|
AddSol(ctx, 0.2550, 0.0000, 0.0000, 0.0000, 0, 0, 2, 1);
|
|
AddSol(ctx, -411.6080, -0.2000, 0.0000, -0.0124, 0, 0, 2, 0);
|
|
AddSol(ctx, 0.5840, 0.8400, 0.0000, 0.0071, 0, 0, 2,-1);
|
|
AddSol(ctx, -55.1730, -52.1400, 0.0000, -0.1052, 0, 0, 2,-2);
|
|
AddSol(ctx, 0.2540, 0.2500, 0.0000, -0.0017, 0, 0, 2,-3);
|
|
AddSol(ctx, 0.0250, -1.6700, 0.0000, 0.0031, 0, 0, 2,-4);
|
|
AddSol(ctx, 1.0600, 2.9600, -0.1660, 0.0243, 3, 0, 0, 2);
|
|
AddSol(ctx, 36.1240, 50.6400, -1.3000, 0.6215, 3, 0, 0, 0);
|
|
AddSol(ctx, -13.1930, -16.4000, 0.2580, -0.1187, 3, 0, 0,-2);
|
|
AddSol(ctx, -1.1870, -0.7400, 0.0420, 0.0074, 3, 0, 0,-4);
|
|
AddSol(ctx, -0.2930, -0.3100, -0.0020, 0.0046, 3, 0, 0,-6);
|
|
AddSol(ctx, -0.2900, -1.4500, 0.1160, -0.0051, 2, 1, 0, 2);
|
|
AddSol(ctx, -7.6490, -10.5600, 0.2590, -0.1038, 2, 1, 0, 0);
|
|
AddSol(ctx, -8.6270, -7.5900, 0.0780, -0.0192, 2, 1, 0,-2);
|
|
AddSol(ctx, -2.7400, -2.5400, 0.0220, 0.0324, 2, 1, 0,-4);
|
|
AddSol(ctx, 1.1810, 3.3200, -0.2120, 0.0213, 2,-1, 0, 2);
|
|
AddSol(ctx, 9.7030, 11.6700, -0.1510, 0.1268, 2,-1, 0, 0);
|
|
AddSol(ctx, -0.3520, -0.3700, 0.0010, -0.0028, 2,-1, 0,-1);
|
|
AddSol(ctx, -2.4940, -1.1700, -0.0030, -0.0017, 2,-1, 0,-2);
|
|
AddSol(ctx, 0.3600, 0.2000, -0.0120, -0.0043, 2,-1, 0,-4);
|
|
AddSol(ctx, -1.1670, -1.2500, 0.0080, -0.0106, 1, 2, 0, 0);
|
|
AddSol(ctx, -7.4120, -6.1200, 0.1170, 0.0484, 1, 2, 0,-2);
|
|
AddSol(ctx, -0.3110, -0.6500, -0.0320, 0.0044, 1, 2, 0,-4);
|
|
AddSol(ctx, 0.7570, 1.8200, -0.1050, 0.0112, 1,-2, 0, 2);
|
|
AddSol(ctx, 2.5800, 2.3200, 0.0270, 0.0196, 1,-2, 0, 0);
|
|
AddSol(ctx, 2.5330, 2.4000, -0.0140, -0.0212, 1,-2, 0,-2);
|
|
AddSol(ctx, -0.3440, -0.5700, -0.0250, 0.0036, 0, 3, 0,-2);
|
|
AddSol(ctx, -0.9920, -0.0200, 0.0000, 0.0000, 1, 0, 2, 2);
|
|
AddSol(ctx, -45.0990, -0.0200, 0.0000, -0.0010, 1, 0, 2, 0);
|
|
AddSol(ctx, -0.1790, -9.5200, 0.0000, -0.0833, 1, 0, 2,-2);
|
|
AddSol(ctx, -0.3010, -0.3300, 0.0000, 0.0014, 1, 0, 2,-4);
|
|
AddSol(ctx, -6.3820, -3.3700, 0.0000, -0.0481, 1, 0,-2, 2);
|
|
AddSol(ctx, 39.5280, 85.1300, 0.0000, -0.7136, 1, 0,-2, 0);
|
|
AddSol(ctx, 9.3660, 0.7100, 0.0000, -0.0112, 1, 0,-2,-2);
|
|
AddSol(ctx, 0.2020, 0.0200, 0.0000, 0.0000, 1, 0,-2,-4);
|
|
AddSol(ctx, 0.4150, 0.1000, 0.0000, 0.0013, 0, 1, 2, 0);
|
|
AddSol(ctx, -2.1520, -2.2600, 0.0000, -0.0066, 0, 1, 2,-2);
|
|
AddSol(ctx, -1.4400, -1.3000, 0.0000, 0.0014, 0, 1,-2, 2);
|
|
AddSol(ctx, 0.3840, -0.0400, 0.0000, 0.0000, 0, 1,-2,-2);
|
|
AddSol(ctx, 1.9380, 3.6000, -0.1450, 0.0401, 4, 0, 0, 0);
|
|
AddSol(ctx, -0.9520, -1.5800, 0.0520, -0.0130, 4, 0, 0,-2);
|
|
AddSol(ctx, -0.5510, -0.9400, 0.0320, -0.0097, 3, 1, 0, 0);
|
|
AddSol(ctx, -0.4820, -0.5700, 0.0050, -0.0045, 3, 1, 0,-2);
|
|
AddSol(ctx, 0.6810, 0.9600, -0.0260, 0.0115, 3,-1, 0, 0);
|
|
AddSol(ctx, -0.2970, -0.2700, 0.0020, -0.0009, 2, 2, 0,-2);
|
|
AddSol(ctx, 0.2540, 0.2100, -0.0030, 0.0000, 2,-2, 0,-2);
|
|
AddSol(ctx, -0.2500, -0.2200, 0.0040, 0.0014, 1, 3, 0,-2);
|
|
AddSol(ctx, -3.9960, 0.0000, 0.0000, 0.0004, 2, 0, 2, 0);
|
|
AddSol(ctx, 0.5570, -0.7500, 0.0000, -0.0090, 2, 0, 2,-2);
|
|
AddSol(ctx, -0.4590, -0.3800, 0.0000, -0.0053, 2, 0,-2, 2);
|
|
AddSol(ctx, -1.2980, 0.7400, 0.0000, 0.0004, 2, 0,-2, 0);
|
|
AddSol(ctx, 0.5380, 1.1400, 0.0000, -0.0141, 2, 0,-2,-2);
|
|
AddSol(ctx, 0.2630, 0.0200, 0.0000, 0.0000, 1, 1, 2, 0);
|
|
AddSol(ctx, 0.4260, 0.0700, 0.0000, -0.0006, 1, 1,-2,-2);
|
|
AddSol(ctx, -0.3040, 0.0300, 0.0000, 0.0003, 1,-1, 2, 0);
|
|
AddSol(ctx, -0.3720, -0.1900, 0.0000, -0.0027, 1,-1,-2, 2);
|
|
AddSol(ctx, 0.4180, 0.0000, 0.0000, 0.0000, 0, 0, 4, 0);
|
|
AddSol(ctx, -0.3300, -0.0400, 0.0000, 0.0000, 3, 0, 2, 0);
|
|
|
|
SolarN(ctx);
|
|
Planetary(ctx);
|
|
S = F + DS/ARC;
|
|
|
|
lat_seconds = (1.000002708 + 139.978*DGAM)*(18518.511+1.189+GAM1C)*sin(S)-6.24*sin(3*S) + N;
|
|
|
|
*geo_eclip_lon = PI2 * Frac((L0+DLAM/ARC) / PI2);
|
|
*geo_eclip_lat = lat_seconds * (DEG2RAD / 3600.0);
|
|
*distance_au = (ARC * EARTH_EQUATORIAL_RADIUS_AU) / (0.999953253 * SINPI);
|
|
++_CalcMoonCount;
|
|
}
|
|
|
|
#undef T
|
|
#undef DGAM
|
|
#undef DLAM
|
|
#undef N
|
|
#undef GAM1C
|
|
#undef SINPI
|
|
#undef L0
|
|
#undef L
|
|
#undef LS
|
|
#undef F
|
|
#undef D
|
|
#undef S
|
|
#undef DL0
|
|
#undef DL
|
|
#undef DLS
|
|
#undef DF
|
|
#undef DD
|
|
#undef DS
|
|
#undef CO
|
|
#undef SI
|
|
|
|
/** @endcond */
|
|
|
|
/**
|
|
* @brief Calculates the geocentric position of the Moon at a given time.
|
|
*
|
|
* Given a time of observation, calculates the Moon's position as a vector.
|
|
* The vector gives the location of the Moon's center relative to the Earth's center
|
|
* with x-, y-, and z-components measured in astronomical units.
|
|
*
|
|
* This algorithm is based on Nautical Almanac Office's *Improved Lunar Ephemeris* of 1954,
|
|
* which in turn derives from E. W. Brown's lunar theories from the early twentieth century.
|
|
* It is adapted from Turbo Pascal code from the book
|
|
* [Astronomy on the Personal Computer](https://www.springer.com/us/book/9783540672210)
|
|
* by Montenbruck and Pfleger.
|
|
*
|
|
* @param time The date and time for which to calculate the Moon's position.
|
|
* @return The Moon's position as a vector in J2000 Cartesian equatorial coordinates.
|
|
*/
|
|
astro_vector_t Astronomy_GeoMoon(astro_time_t time)
|
|
{
|
|
double geo_eclip_lon, geo_eclip_lat, distance_au;
|
|
double dist_cos_lat;
|
|
astro_vector_t vector;
|
|
double gepos[3];
|
|
double mpos1[3];
|
|
double mpos2[3];
|
|
|
|
CalcMoon(time.tt / 36525.0, &geo_eclip_lon, &geo_eclip_lat, &distance_au);
|
|
|
|
/* Convert geocentric ecliptic spherical coordinates to Cartesian coordinates. */
|
|
dist_cos_lat = distance_au * cos(geo_eclip_lat);
|
|
gepos[0] = dist_cos_lat * cos(geo_eclip_lon);
|
|
gepos[1] = dist_cos_lat * sin(geo_eclip_lon);
|
|
gepos[2] = distance_au * sin(geo_eclip_lat);
|
|
|
|
/* Convert ecliptic coordinates to equatorial coordinates, both in mean equinox of date. */
|
|
ecl2equ_vec(time, gepos, mpos1);
|
|
|
|
/* Convert from mean equinox of date to J2000. */
|
|
precession(time.tt, mpos1, 0, mpos2);
|
|
|
|
vector.status = ASTRO_SUCCESS;
|
|
vector.x = mpos2[0];
|
|
vector.y = mpos2[1];
|
|
vector.z = mpos2[2];
|
|
vector.t = time;
|
|
return vector;
|
|
}
|
|
|
|
/*------------------ VSOP ------------------*/
|
|
|
|
/** @cond DOXYGEN_SKIP */
|
|
typedef struct
|
|
{
|
|
double amplitude;
|
|
double phase;
|
|
double frequency;
|
|
}
|
|
vsop_term_t;
|
|
|
|
typedef struct
|
|
{
|
|
int nterms;
|
|
const vsop_term_t *term;
|
|
}
|
|
vsop_series_t;
|
|
|
|
typedef struct
|
|
{
|
|
int nseries;
|
|
const vsop_series_t *series;
|
|
}
|
|
vsop_formula_t;
|
|
|
|
typedef struct
|
|
{
|
|
const vsop_formula_t formula[3];
|
|
}
|
|
vsop_model_t;
|
|
/** @endcond */
|
|
|
|
static const vsop_term_t vsop_lon_Mercury_0[] =
|
|
{
|
|
{ 4.40250710144, 0.00000000000, 0.00000000000 },
|
|
{ 0.40989414977, 1.48302034195, 26087.90314157420 },
|
|
{ 0.05046294200, 4.47785489551, 52175.80628314840 },
|
|
{ 0.00855346844, 1.16520322459, 78263.70942472259 },
|
|
{ 0.00165590362, 4.11969163423, 104351.61256629678 },
|
|
{ 0.00034561897, 0.77930768443, 130439.51570787099 },
|
|
{ 0.00007583476, 3.71348404924, 156527.41884944518 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lon_Mercury_1[] =
|
|
{
|
|
{ 26087.90313685529, 0.00000000000, 0.00000000000 },
|
|
{ 0.01131199811, 6.21874197797, 26087.90314157420 },
|
|
{ 0.00292242298, 3.04449355541, 52175.80628314840 },
|
|
{ 0.00075775081, 6.08568821653, 78263.70942472259 },
|
|
{ 0.00019676525, 2.80965111777, 104351.61256629678 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_lon_Mercury[] =
|
|
{
|
|
{ 7, vsop_lon_Mercury_0 },
|
|
{ 5, vsop_lon_Mercury_1 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lat_Mercury_0[] =
|
|
{
|
|
{ 0.11737528961, 1.98357498767, 26087.90314157420 },
|
|
{ 0.02388076996, 5.03738959686, 52175.80628314840 },
|
|
{ 0.01222839532, 3.14159265359, 0.00000000000 },
|
|
{ 0.00543251810, 1.79644363964, 78263.70942472259 },
|
|
{ 0.00129778770, 4.83232503958, 104351.61256629678 },
|
|
{ 0.00031866927, 1.58088495658, 130439.51570787099 },
|
|
{ 0.00007963301, 4.60972126127, 156527.41884944518 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lat_Mercury_1[] =
|
|
{
|
|
{ 0.00274646065, 3.95008450011, 26087.90314157420 },
|
|
{ 0.00099737713, 3.14159265359, 0.00000000000 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_lat_Mercury[] =
|
|
{
|
|
{ 7, vsop_lat_Mercury_0 },
|
|
{ 2, vsop_lat_Mercury_1 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_rad_Mercury_0[] =
|
|
{
|
|
{ 0.39528271651, 0.00000000000, 0.00000000000 },
|
|
{ 0.07834131818, 6.19233722598, 26087.90314157420 },
|
|
{ 0.00795525558, 2.95989690104, 52175.80628314840 },
|
|
{ 0.00121281764, 6.01064153797, 78263.70942472259 },
|
|
{ 0.00021921969, 2.77820093972, 104351.61256629678 },
|
|
{ 0.00004354065, 5.82894543774, 130439.51570787099 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_rad_Mercury_1[] =
|
|
{
|
|
{ 0.00217347740, 4.65617158665, 26087.90314157420 },
|
|
{ 0.00044141826, 1.42385544001, 52175.80628314840 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_rad_Mercury[] =
|
|
{
|
|
{ 6, vsop_rad_Mercury_0 },
|
|
{ 2, vsop_rad_Mercury_1 }
|
|
};
|
|
|
|
;
|
|
static const vsop_term_t vsop_lon_Venus_0[] =
|
|
{
|
|
{ 3.17614666774, 0.00000000000, 0.00000000000 },
|
|
{ 0.01353968419, 5.59313319619, 10213.28554621100 },
|
|
{ 0.00089891645, 5.30650047764, 20426.57109242200 },
|
|
{ 0.00005477194, 4.41630661466, 7860.41939243920 },
|
|
{ 0.00003455741, 2.69964447820, 11790.62908865880 },
|
|
{ 0.00002372061, 2.99377542079, 3930.20969621960 },
|
|
{ 0.00001317168, 5.18668228402, 26.29831979980 },
|
|
{ 0.00001664146, 4.25018630147, 1577.34354244780 },
|
|
{ 0.00001438387, 4.15745084182, 9683.59458111640 },
|
|
{ 0.00001200521, 6.15357116043, 30639.85663863300 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lon_Venus_1[] =
|
|
{
|
|
{ 10213.28554621638, 0.00000000000, 0.00000000000 },
|
|
{ 0.00095617813, 2.46406511110, 10213.28554621100 },
|
|
{ 0.00007787201, 0.62478482220, 20426.57109242200 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_lon_Venus[] =
|
|
{
|
|
{ 10, vsop_lon_Venus_0 },
|
|
{ 3, vsop_lon_Venus_1 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lat_Venus_0[] =
|
|
{
|
|
{ 0.05923638472, 0.26702775812, 10213.28554621100 },
|
|
{ 0.00040107978, 1.14737178112, 20426.57109242200 },
|
|
{ 0.00032814918, 3.14159265359, 0.00000000000 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lat_Venus_1[] =
|
|
{
|
|
{ 0.00287821243, 1.88964962838, 10213.28554621100 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_lat_Venus[] =
|
|
{
|
|
{ 3, vsop_lat_Venus_0 },
|
|
{ 1, vsop_lat_Venus_1 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_rad_Venus_0[] =
|
|
{
|
|
{ 0.72334820891, 0.00000000000, 0.00000000000 },
|
|
{ 0.00489824182, 4.02151831717, 10213.28554621100 },
|
|
{ 0.00001658058, 4.90206728031, 20426.57109242200 },
|
|
{ 0.00001378043, 1.12846591367, 11790.62908865880 },
|
|
{ 0.00001632096, 2.84548795207, 7860.41939243920 },
|
|
{ 0.00000498395, 2.58682193892, 9683.59458111640 },
|
|
{ 0.00000221985, 2.01346696541, 19367.18916223280 },
|
|
{ 0.00000237454, 2.55136053886, 15720.83878487840 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_rad_Venus_1[] =
|
|
{
|
|
{ 0.00034551041, 0.89198706276, 10213.28554621100 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_rad_Venus[] =
|
|
{
|
|
{ 8, vsop_rad_Venus_0 },
|
|
{ 1, vsop_rad_Venus_1 }
|
|
};
|
|
|
|
;
|
|
static const vsop_term_t vsop_lon_Earth_0[] =
|
|
{
|
|
{ 1.75347045673, 0.00000000000, 0.00000000000 },
|
|
{ 0.03341656453, 4.66925680415, 6283.07584999140 },
|
|
{ 0.00034894275, 4.62610242189, 12566.15169998280 },
|
|
{ 0.00003417572, 2.82886579754, 3.52311834900 },
|
|
{ 0.00003497056, 2.74411783405, 5753.38488489680 },
|
|
{ 0.00003135899, 3.62767041756, 77713.77146812050 },
|
|
{ 0.00002676218, 4.41808345438, 7860.41939243920 },
|
|
{ 0.00002342691, 6.13516214446, 3930.20969621960 },
|
|
{ 0.00001273165, 2.03709657878, 529.69096509460 },
|
|
{ 0.00001324294, 0.74246341673, 11506.76976979360 },
|
|
{ 0.00000901854, 2.04505446477, 26.29831979980 },
|
|
{ 0.00001199167, 1.10962946234, 1577.34354244780 },
|
|
{ 0.00000857223, 3.50849152283, 398.14900340820 },
|
|
{ 0.00000779786, 1.17882681962, 5223.69391980220 },
|
|
{ 0.00000990250, 5.23268072088, 5884.92684658320 },
|
|
{ 0.00000753141, 2.53339052847, 5507.55323866740 },
|
|
{ 0.00000505267, 4.58292599973, 18849.22754997420 },
|
|
{ 0.00000492392, 4.20505711826, 775.52261132400 },
|
|
{ 0.00000356672, 2.91954114478, 0.06731030280 },
|
|
{ 0.00000284125, 1.89869240932, 796.29800681640 },
|
|
{ 0.00000242879, 0.34481445893, 5486.77784317500 },
|
|
{ 0.00000317087, 5.84901948512, 11790.62908865880 },
|
|
{ 0.00000271112, 0.31486255375, 10977.07880469900 },
|
|
{ 0.00000206217, 4.80646631478, 2544.31441988340 },
|
|
{ 0.00000205478, 1.86953770281, 5573.14280143310 },
|
|
{ 0.00000202318, 2.45767790232, 6069.77675455340 },
|
|
{ 0.00000126225, 1.08295459501, 20.77539549240 },
|
|
{ 0.00000155516, 0.83306084617, 213.29909543800 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lon_Earth_1[] =
|
|
{
|
|
{ 6283.07584999140, 0.00000000000, 0.00000000000 },
|
|
{ 0.00206058863, 2.67823455808, 6283.07584999140 },
|
|
{ 0.00004303419, 2.63512233481, 12566.15169998280 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lon_Earth_2[] =
|
|
{
|
|
{ 0.00008721859, 1.07253635559, 6283.07584999140 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_lon_Earth[] =
|
|
{
|
|
{ 28, vsop_lon_Earth_0 },
|
|
{ 3, vsop_lon_Earth_1 },
|
|
{ 1, vsop_lon_Earth_2 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lat_Earth_1[] =
|
|
{
|
|
{ 0.00227777722, 3.41376620530, 6283.07584999140 },
|
|
{ 0.00003805678, 3.37063423795, 12566.15169998280 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_lat_Earth[] =
|
|
{
|
|
{ 0, NULL },
|
|
{ 2, vsop_lat_Earth_1 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_rad_Earth_0[] =
|
|
{
|
|
{ 1.00013988784, 0.00000000000, 0.00000000000 },
|
|
{ 0.01670699632, 3.09846350258, 6283.07584999140 },
|
|
{ 0.00013956024, 3.05524609456, 12566.15169998280 },
|
|
{ 0.00003083720, 5.19846674381, 77713.77146812050 },
|
|
{ 0.00001628463, 1.17387558054, 5753.38488489680 },
|
|
{ 0.00001575572, 2.84685214877, 7860.41939243920 },
|
|
{ 0.00000924799, 5.45292236722, 11506.76976979360 },
|
|
{ 0.00000542439, 4.56409151453, 3930.20969621960 },
|
|
{ 0.00000472110, 3.66100022149, 5884.92684658320 },
|
|
{ 0.00000085831, 1.27079125277, 161000.68573767410 },
|
|
{ 0.00000057056, 2.01374292245, 83996.84731811189 },
|
|
{ 0.00000055736, 5.24159799170, 71430.69561812909 },
|
|
{ 0.00000174844, 3.01193636733, 18849.22754997420 },
|
|
{ 0.00000243181, 4.27349530790, 11790.62908865880 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_rad_Earth_1[] =
|
|
{
|
|
{ 0.00103018607, 1.10748968172, 6283.07584999140 },
|
|
{ 0.00001721238, 1.06442300386, 12566.15169998280 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_rad_Earth_2[] =
|
|
{
|
|
{ 0.00004359385, 5.78455133808, 6283.07584999140 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_rad_Earth[] =
|
|
{
|
|
{ 14, vsop_rad_Earth_0 },
|
|
{ 2, vsop_rad_Earth_1 },
|
|
{ 1, vsop_rad_Earth_2 }
|
|
};
|
|
|
|
;
|
|
static const vsop_term_t vsop_lon_Mars_0[] =
|
|
{
|
|
{ 6.20347711581, 0.00000000000, 0.00000000000 },
|
|
{ 0.18656368093, 5.05037100270, 3340.61242669980 },
|
|
{ 0.01108216816, 5.40099836344, 6681.22485339960 },
|
|
{ 0.00091798406, 5.75478744667, 10021.83728009940 },
|
|
{ 0.00027744987, 5.97049513147, 3.52311834900 },
|
|
{ 0.00010610235, 2.93958560338, 2281.23049651060 },
|
|
{ 0.00012315897, 0.84956094002, 2810.92146160520 },
|
|
{ 0.00008926784, 4.15697846427, 0.01725365220 },
|
|
{ 0.00008715691, 6.11005153139, 13362.44970679920 },
|
|
{ 0.00006797556, 0.36462229657, 398.14900340820 },
|
|
{ 0.00007774872, 3.33968761376, 5621.84292321040 },
|
|
{ 0.00003575078, 1.66186505710, 2544.31441988340 },
|
|
{ 0.00004161108, 0.22814971327, 2942.46342329160 },
|
|
{ 0.00003075252, 0.85696614132, 191.44826611160 },
|
|
{ 0.00002628117, 0.64806124465, 3337.08930835080 },
|
|
{ 0.00002937546, 6.07893711402, 0.06731030280 },
|
|
{ 0.00002389414, 5.03896442664, 796.29800681640 },
|
|
{ 0.00002579844, 0.02996736156, 3344.13554504880 },
|
|
{ 0.00001528141, 1.14979301996, 6151.53388830500 },
|
|
{ 0.00001798806, 0.65634057445, 529.69096509460 },
|
|
{ 0.00001264357, 3.62275122593, 5092.15195811580 },
|
|
{ 0.00001286228, 3.06796065034, 2146.16541647520 },
|
|
{ 0.00001546404, 2.91579701718, 1751.53953141600 },
|
|
{ 0.00001024902, 3.69334099279, 8962.45534991020 },
|
|
{ 0.00000891566, 0.18293837498, 16703.06213349900 },
|
|
{ 0.00000858759, 2.40093811940, 2914.01423582380 },
|
|
{ 0.00000832715, 2.46418619474, 3340.59517304760 },
|
|
{ 0.00000832720, 4.49495782139, 3340.62968035200 },
|
|
{ 0.00000712902, 3.66335473479, 1059.38193018920 },
|
|
{ 0.00000748723, 3.82248614017, 155.42039943420 },
|
|
{ 0.00000723861, 0.67497311481, 3738.76143010800 },
|
|
{ 0.00000635548, 2.92182225127, 8432.76438481560 },
|
|
{ 0.00000655162, 0.48864064125, 3127.31333126180 },
|
|
{ 0.00000550474, 3.81001042328, 0.98032106820 },
|
|
{ 0.00000552750, 4.47479317037, 1748.01641306700 },
|
|
{ 0.00000425966, 0.55364317304, 6283.07584999140 },
|
|
{ 0.00000415131, 0.49662285038, 213.29909543800 },
|
|
{ 0.00000472167, 3.62547124025, 1194.44701022460 },
|
|
{ 0.00000306551, 0.38052848348, 6684.74797174860 },
|
|
{ 0.00000312141, 0.99853944405, 6677.70173505060 },
|
|
{ 0.00000293198, 4.22131299634, 20.77539549240 },
|
|
{ 0.00000302375, 4.48618007156, 3532.06069281140 },
|
|
{ 0.00000274027, 0.54222167059, 3340.54511639700 },
|
|
{ 0.00000281079, 5.88163521788, 1349.86740965880 },
|
|
{ 0.00000231183, 1.28242156993, 3870.30339179440 },
|
|
{ 0.00000283602, 5.76885434940, 3149.16416058820 },
|
|
{ 0.00000236117, 5.75503217933, 3333.49887969900 },
|
|
{ 0.00000274033, 0.13372524985, 3340.67973700260 },
|
|
{ 0.00000299395, 2.78323740866, 6254.62666252360 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lon_Mars_1[] =
|
|
{
|
|
{ 3340.61242700512, 0.00000000000, 0.00000000000 },
|
|
{ 0.01457554523, 3.60433733236, 3340.61242669980 },
|
|
{ 0.00168414711, 3.92318567804, 6681.22485339960 },
|
|
{ 0.00020622975, 4.26108844583, 10021.83728009940 },
|
|
{ 0.00003452392, 4.73210393190, 3.52311834900 },
|
|
{ 0.00002586332, 4.60670058555, 13362.44970679920 },
|
|
{ 0.00000841535, 4.45864030426, 2281.23049651060 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lon_Mars_2[] =
|
|
{
|
|
{ 0.00058152577, 2.04961712429, 3340.61242669980 },
|
|
{ 0.00013459579, 2.45738706163, 6681.22485339960 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_lon_Mars[] =
|
|
{
|
|
{ 49, vsop_lon_Mars_0 },
|
|
{ 7, vsop_lon_Mars_1 },
|
|
{ 2, vsop_lon_Mars_2 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lat_Mars_0[] =
|
|
{
|
|
{ 0.03197134986, 3.76832042431, 3340.61242669980 },
|
|
{ 0.00298033234, 4.10616996305, 6681.22485339960 },
|
|
{ 0.00289104742, 0.00000000000, 0.00000000000 },
|
|
{ 0.00031365539, 4.44651053090, 10021.83728009940 },
|
|
{ 0.00003484100, 4.78812549260, 13362.44970679920 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lat_Mars_1[] =
|
|
{
|
|
{ 0.00217310991, 6.04472194776, 3340.61242669980 },
|
|
{ 0.00020976948, 3.14159265359, 0.00000000000 },
|
|
{ 0.00012834709, 1.60810667915, 6681.22485339960 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_lat_Mars[] =
|
|
{
|
|
{ 5, vsop_lat_Mars_0 },
|
|
{ 3, vsop_lat_Mars_1 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_rad_Mars_0[] =
|
|
{
|
|
{ 1.53033488271, 0.00000000000, 0.00000000000 },
|
|
{ 0.14184953160, 3.47971283528, 3340.61242669980 },
|
|
{ 0.00660776362, 3.81783443019, 6681.22485339960 },
|
|
{ 0.00046179117, 4.15595316782, 10021.83728009940 },
|
|
{ 0.00008109733, 5.55958416318, 2810.92146160520 },
|
|
{ 0.00007485318, 1.77239078402, 5621.84292321040 },
|
|
{ 0.00005523191, 1.36436303770, 2281.23049651060 },
|
|
{ 0.00003825160, 4.49407183687, 13362.44970679920 },
|
|
{ 0.00002306537, 0.09081579001, 2544.31441988340 },
|
|
{ 0.00001999396, 5.36059617709, 3337.08930835080 },
|
|
{ 0.00002484394, 4.92545639920, 2942.46342329160 },
|
|
{ 0.00001960195, 4.74249437639, 3344.13554504880 },
|
|
{ 0.00001167119, 2.11260868341, 5092.15195811580 },
|
|
{ 0.00001102816, 5.00908403998, 398.14900340820 },
|
|
{ 0.00000899066, 4.40791133207, 529.69096509460 },
|
|
{ 0.00000992252, 5.83861961952, 6151.53388830500 },
|
|
{ 0.00000807354, 2.10217065501, 1059.38193018920 },
|
|
{ 0.00000797915, 3.44839203899, 796.29800681640 },
|
|
{ 0.00000740975, 1.49906336885, 2146.16541647520 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_rad_Mars_1[] =
|
|
{
|
|
{ 0.01107433345, 2.03250524857, 3340.61242669980 },
|
|
{ 0.00103175887, 2.37071847807, 6681.22485339960 },
|
|
{ 0.00012877200, 0.00000000000, 0.00000000000 },
|
|
{ 0.00010815880, 2.70888095665, 10021.83728009940 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_rad_Mars_2[] =
|
|
{
|
|
{ 0.00044242249, 0.47930604954, 3340.61242669980 },
|
|
{ 0.00008138042, 0.86998389204, 6681.22485339960 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_rad_Mars[] =
|
|
{
|
|
{ 19, vsop_rad_Mars_0 },
|
|
{ 4, vsop_rad_Mars_1 },
|
|
{ 2, vsop_rad_Mars_2 }
|
|
};
|
|
|
|
;
|
|
static const vsop_term_t vsop_lon_Jupiter_0[] =
|
|
{
|
|
{ 0.59954691494, 0.00000000000, 0.00000000000 },
|
|
{ 0.09695898719, 5.06191793158, 529.69096509460 },
|
|
{ 0.00573610142, 1.44406205629, 7.11354700080 },
|
|
{ 0.00306389205, 5.41734730184, 1059.38193018920 },
|
|
{ 0.00097178296, 4.14264726552, 632.78373931320 },
|
|
{ 0.00072903078, 3.64042916389, 522.57741809380 },
|
|
{ 0.00064263975, 3.41145165351, 103.09277421860 },
|
|
{ 0.00039806064, 2.29376740788, 419.48464387520 },
|
|
{ 0.00038857767, 1.27231755835, 316.39186965660 },
|
|
{ 0.00027964629, 1.78454591820, 536.80451209540 },
|
|
{ 0.00013589730, 5.77481040790, 1589.07289528380 },
|
|
{ 0.00008246349, 3.58227925840, 206.18554843720 },
|
|
{ 0.00008768704, 3.63000308199, 949.17560896980 },
|
|
{ 0.00007368042, 5.08101194270, 735.87651353180 },
|
|
{ 0.00006263150, 0.02497628807, 213.29909543800 },
|
|
{ 0.00006114062, 4.51319998626, 1162.47470440780 },
|
|
{ 0.00004905396, 1.32084470588, 110.20632121940 },
|
|
{ 0.00005305285, 1.30671216791, 14.22709400160 },
|
|
{ 0.00005305441, 4.18625634012, 1052.26838318840 },
|
|
{ 0.00004647248, 4.69958103684, 3.93215326310 },
|
|
{ 0.00003045023, 4.31676431084, 426.59819087600 },
|
|
{ 0.00002609999, 1.56667394063, 846.08283475120 },
|
|
{ 0.00002028191, 1.06376530715, 3.18139373770 },
|
|
{ 0.00001764763, 2.14148655117, 1066.49547719000 },
|
|
{ 0.00001722972, 3.88036268267, 1265.56747862640 },
|
|
{ 0.00001920945, 0.97168196472, 639.89728631400 },
|
|
{ 0.00001633223, 3.58201833555, 515.46387109300 },
|
|
{ 0.00001431999, 4.29685556046, 625.67019231240 },
|
|
{ 0.00000973272, 4.09764549134, 95.97922721780 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lon_Jupiter_1[] =
|
|
{
|
|
{ 529.69096508814, 0.00000000000, 0.00000000000 },
|
|
{ 0.00489503243, 4.22082939470, 529.69096509460 },
|
|
{ 0.00228917222, 6.02646855621, 7.11354700080 },
|
|
{ 0.00030099479, 4.54540782858, 1059.38193018920 },
|
|
{ 0.00020720920, 5.45943156902, 522.57741809380 },
|
|
{ 0.00012103653, 0.16994816098, 536.80451209540 },
|
|
{ 0.00006067987, 4.42422292017, 103.09277421860 },
|
|
{ 0.00005433968, 3.98480737746, 419.48464387520 },
|
|
{ 0.00004237744, 5.89008707199, 14.22709400160 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lon_Jupiter_2[] =
|
|
{
|
|
{ 0.00047233601, 4.32148536482, 7.11354700080 },
|
|
{ 0.00030649436, 2.92977788700, 529.69096509460 },
|
|
{ 0.00014837605, 3.14159265359, 0.00000000000 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_lon_Jupiter[] =
|
|
{
|
|
{ 29, vsop_lon_Jupiter_0 },
|
|
{ 9, vsop_lon_Jupiter_1 },
|
|
{ 3, vsop_lon_Jupiter_2 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lat_Jupiter_0[] =
|
|
{
|
|
{ 0.02268615702, 3.55852606721, 529.69096509460 },
|
|
{ 0.00109971634, 3.90809347197, 1059.38193018920 },
|
|
{ 0.00110090358, 0.00000000000, 0.00000000000 },
|
|
{ 0.00008101428, 3.60509572885, 522.57741809380 },
|
|
{ 0.00006043996, 4.25883108339, 1589.07289528380 },
|
|
{ 0.00006437782, 0.30627119215, 536.80451209540 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lat_Jupiter_1[] =
|
|
{
|
|
{ 0.00078203446, 1.52377859742, 529.69096509460 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_lat_Jupiter[] =
|
|
{
|
|
{ 6, vsop_lat_Jupiter_0 },
|
|
{ 1, vsop_lat_Jupiter_1 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_rad_Jupiter_0[] =
|
|
{
|
|
{ 5.20887429326, 0.00000000000, 0.00000000000 },
|
|
{ 0.25209327119, 3.49108639871, 529.69096509460 },
|
|
{ 0.00610599976, 3.84115365948, 1059.38193018920 },
|
|
{ 0.00282029458, 2.57419881293, 632.78373931320 },
|
|
{ 0.00187647346, 2.07590383214, 522.57741809380 },
|
|
{ 0.00086792905, 0.71001145545, 419.48464387520 },
|
|
{ 0.00072062974, 0.21465724607, 536.80451209540 },
|
|
{ 0.00065517248, 5.97995884790, 316.39186965660 },
|
|
{ 0.00029134542, 1.67759379655, 103.09277421860 },
|
|
{ 0.00030135335, 2.16132003734, 949.17560896980 },
|
|
{ 0.00023453271, 3.54023522184, 735.87651353180 },
|
|
{ 0.00022283743, 4.19362594399, 1589.07289528380 },
|
|
{ 0.00023947298, 0.27458037480, 7.11354700080 },
|
|
{ 0.00013032614, 2.96042965363, 1162.47470440780 },
|
|
{ 0.00009703360, 1.90669633585, 206.18554843720 },
|
|
{ 0.00012749023, 2.71550286592, 1052.26838318840 },
|
|
{ 0.00007057931, 2.18184839926, 1265.56747862640 },
|
|
{ 0.00006137703, 6.26418240033, 846.08283475120 },
|
|
{ 0.00002616976, 2.00994012876, 1581.95934828300 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_rad_Jupiter_1[] =
|
|
{
|
|
{ 0.01271801520, 2.64937512894, 529.69096509460 },
|
|
{ 0.00061661816, 3.00076460387, 1059.38193018920 },
|
|
{ 0.00053443713, 3.89717383175, 522.57741809380 },
|
|
{ 0.00031185171, 4.88276958012, 536.80451209540 },
|
|
{ 0.00041390269, 0.00000000000, 0.00000000000 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_rad_Jupiter[] =
|
|
{
|
|
{ 19, vsop_rad_Jupiter_0 },
|
|
{ 5, vsop_rad_Jupiter_1 }
|
|
};
|
|
|
|
;
|
|
static const vsop_term_t vsop_lon_Saturn_0[] =
|
|
{
|
|
{ 0.87401354025, 0.00000000000, 0.00000000000 },
|
|
{ 0.11107659762, 3.96205090159, 213.29909543800 },
|
|
{ 0.01414150957, 4.58581516874, 7.11354700080 },
|
|
{ 0.00398379389, 0.52112032699, 206.18554843720 },
|
|
{ 0.00350769243, 3.30329907896, 426.59819087600 },
|
|
{ 0.00206816305, 0.24658372002, 103.09277421860 },
|
|
{ 0.00079271300, 3.84007056878, 220.41264243880 },
|
|
{ 0.00023990355, 4.66976924553, 110.20632121940 },
|
|
{ 0.00016573588, 0.43719228296, 419.48464387520 },
|
|
{ 0.00014906995, 5.76903183869, 316.39186965660 },
|
|
{ 0.00015820290, 0.93809155235, 632.78373931320 },
|
|
{ 0.00014609559, 1.56518472000, 3.93215326310 },
|
|
{ 0.00013160301, 4.44891291899, 14.22709400160 },
|
|
{ 0.00015053543, 2.71669915667, 639.89728631400 },
|
|
{ 0.00013005299, 5.98119023644, 11.04570026390 },
|
|
{ 0.00010725067, 3.12939523827, 202.25339517410 },
|
|
{ 0.00005863206, 0.23656938524, 529.69096509460 },
|
|
{ 0.00005227757, 4.20783365759, 3.18139373770 },
|
|
{ 0.00006126317, 1.76328667907, 277.03499374140 },
|
|
{ 0.00005019687, 3.17787728405, 433.71173787680 },
|
|
{ 0.00004592550, 0.61977744975, 199.07200143640 },
|
|
{ 0.00004005867, 2.24479718502, 63.73589830340 },
|
|
{ 0.00002953796, 0.98280366998, 95.97922721780 },
|
|
{ 0.00003873670, 3.22283226966, 138.51749687070 },
|
|
{ 0.00002461186, 2.03163875071, 735.87651353180 },
|
|
{ 0.00003269484, 0.77492638211, 949.17560896980 },
|
|
{ 0.00001758145, 3.26580109940, 522.57741809380 },
|
|
{ 0.00001640172, 5.50504453050, 846.08283475120 },
|
|
{ 0.00001391327, 4.02333150505, 323.50541665740 },
|
|
{ 0.00001580648, 4.37265307169, 309.27832265580 },
|
|
{ 0.00001123498, 2.83726798446, 415.55249061210 },
|
|
{ 0.00001017275, 3.71700135395, 227.52618943960 },
|
|
{ 0.00000848642, 3.19150170830, 209.36694217490 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lon_Saturn_1[] =
|
|
{
|
|
{ 213.29909521690, 0.00000000000, 0.00000000000 },
|
|
{ 0.01297370862, 1.82834923978, 213.29909543800 },
|
|
{ 0.00564345393, 2.88499717272, 7.11354700080 },
|
|
{ 0.00093734369, 1.06311793502, 426.59819087600 },
|
|
{ 0.00107674962, 2.27769131009, 206.18554843720 },
|
|
{ 0.00040244455, 2.04108104671, 220.41264243880 },
|
|
{ 0.00019941774, 1.27954390470, 103.09277421860 },
|
|
{ 0.00010511678, 2.74880342130, 14.22709400160 },
|
|
{ 0.00006416106, 0.38238295041, 639.89728631400 },
|
|
{ 0.00004848994, 2.43037610229, 419.48464387520 },
|
|
{ 0.00004056892, 2.92133209468, 110.20632121940 },
|
|
{ 0.00003768635, 3.64965330780, 3.93215326310 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lon_Saturn_2[] =
|
|
{
|
|
{ 0.00116441330, 1.17988132879, 7.11354700080 },
|
|
{ 0.00091841837, 0.07325195840, 213.29909543800 },
|
|
{ 0.00036661728, 0.00000000000, 0.00000000000 },
|
|
{ 0.00015274496, 4.06493179167, 206.18554843720 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_lon_Saturn[] =
|
|
{
|
|
{ 33, vsop_lon_Saturn_0 },
|
|
{ 12, vsop_lon_Saturn_1 },
|
|
{ 4, vsop_lon_Saturn_2 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lat_Saturn_0[] =
|
|
{
|
|
{ 0.04330678039, 3.60284428399, 213.29909543800 },
|
|
{ 0.00240348302, 2.85238489373, 426.59819087600 },
|
|
{ 0.00084745939, 0.00000000000, 0.00000000000 },
|
|
{ 0.00030863357, 3.48441504555, 220.41264243880 },
|
|
{ 0.00034116062, 0.57297307557, 206.18554843720 },
|
|
{ 0.00014734070, 2.11846596715, 639.89728631400 },
|
|
{ 0.00009916667, 5.79003188904, 419.48464387520 },
|
|
{ 0.00006993564, 4.73604689720, 7.11354700080 },
|
|
{ 0.00004807588, 5.43305312061, 316.39186965660 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lat_Saturn_1[] =
|
|
{
|
|
{ 0.00198927992, 4.93901017903, 213.29909543800 },
|
|
{ 0.00036947916, 3.14159265359, 0.00000000000 },
|
|
{ 0.00017966989, 0.51979431110, 426.59819087600 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_lat_Saturn[] =
|
|
{
|
|
{ 9, vsop_lat_Saturn_0 },
|
|
{ 3, vsop_lat_Saturn_1 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_rad_Saturn_0[] =
|
|
{
|
|
{ 9.55758135486, 0.00000000000, 0.00000000000 },
|
|
{ 0.52921382865, 2.39226219573, 213.29909543800 },
|
|
{ 0.01873679867, 5.23549604660, 206.18554843720 },
|
|
{ 0.01464663929, 1.64763042902, 426.59819087600 },
|
|
{ 0.00821891141, 5.93520042303, 316.39186965660 },
|
|
{ 0.00547506923, 5.01532618980, 103.09277421860 },
|
|
{ 0.00371684650, 2.27114821115, 220.41264243880 },
|
|
{ 0.00361778765, 3.13904301847, 7.11354700080 },
|
|
{ 0.00140617506, 5.70406606781, 632.78373931320 },
|
|
{ 0.00108974848, 3.29313390175, 110.20632121940 },
|
|
{ 0.00069006962, 5.94099540992, 419.48464387520 },
|
|
{ 0.00061053367, 0.94037691801, 639.89728631400 },
|
|
{ 0.00048913294, 1.55733638681, 202.25339517410 },
|
|
{ 0.00034143772, 0.19519102597, 277.03499374140 },
|
|
{ 0.00032401773, 5.47084567016, 949.17560896980 },
|
|
{ 0.00020936596, 0.46349251129, 735.87651353180 },
|
|
{ 0.00009796004, 5.20477537945, 1265.56747862640 },
|
|
{ 0.00011993338, 5.98050967385, 846.08283475120 },
|
|
{ 0.00020839300, 1.52102476129, 433.71173787680 },
|
|
{ 0.00015298404, 3.05943814940, 529.69096509460 },
|
|
{ 0.00006465823, 0.17732249942, 1052.26838318840 },
|
|
{ 0.00011380257, 1.73105427040, 522.57741809380 },
|
|
{ 0.00003419618, 4.94550542171, 1581.95934828300 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_rad_Saturn_1[] =
|
|
{
|
|
{ 0.06182981340, 0.25843511480, 213.29909543800 },
|
|
{ 0.00506577242, 0.71114625261, 206.18554843720 },
|
|
{ 0.00341394029, 5.79635741658, 426.59819087600 },
|
|
{ 0.00188491195, 0.47215589652, 220.41264243880 },
|
|
{ 0.00186261486, 3.14159265359, 0.00000000000 },
|
|
{ 0.00143891146, 1.40744822888, 7.11354700080 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_rad_Saturn_2[] =
|
|
{
|
|
{ 0.00436902572, 4.78671677509, 213.29909543800 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_rad_Saturn[] =
|
|
{
|
|
{ 23, vsop_rad_Saturn_0 },
|
|
{ 6, vsop_rad_Saturn_1 },
|
|
{ 1, vsop_rad_Saturn_2 }
|
|
};
|
|
|
|
;
|
|
static const vsop_term_t vsop_lon_Uranus_0[] =
|
|
{
|
|
{ 5.48129294297, 0.00000000000, 0.00000000000 },
|
|
{ 0.09260408234, 0.89106421507, 74.78159856730 },
|
|
{ 0.01504247898, 3.62719260920, 1.48447270830 },
|
|
{ 0.00365981674, 1.89962179044, 73.29712585900 },
|
|
{ 0.00272328168, 3.35823706307, 149.56319713460 },
|
|
{ 0.00070328461, 5.39254450063, 63.73589830340 },
|
|
{ 0.00068892678, 6.09292483287, 76.26607127560 },
|
|
{ 0.00061998615, 2.26952066061, 2.96894541660 },
|
|
{ 0.00061950719, 2.85098872691, 11.04570026390 },
|
|
{ 0.00026468770, 3.14152083966, 71.81265315070 },
|
|
{ 0.00025710476, 6.11379840493, 454.90936652730 },
|
|
{ 0.00021078850, 4.36059339067, 148.07872442630 },
|
|
{ 0.00017818647, 1.74436930289, 36.64856292950 },
|
|
{ 0.00014613507, 4.73732166022, 3.93215326310 },
|
|
{ 0.00011162509, 5.82681796350, 224.34479570190 },
|
|
{ 0.00010997910, 0.48865004018, 138.51749687070 },
|
|
{ 0.00009527478, 2.95516862826, 35.16409022120 },
|
|
{ 0.00007545601, 5.23626582400, 109.94568878850 },
|
|
{ 0.00004220241, 3.23328220918, 70.84944530420 },
|
|
{ 0.00004051900, 2.27755017300, 151.04766984290 },
|
|
{ 0.00003354596, 1.06549007380, 4.45341812490 },
|
|
{ 0.00002926718, 4.62903718891, 9.56122755560 },
|
|
{ 0.00003490340, 5.48306144511, 146.59425171800 },
|
|
{ 0.00003144069, 4.75199570434, 77.75054398390 },
|
|
{ 0.00002922333, 5.35235361027, 85.82729883120 },
|
|
{ 0.00002272788, 4.36600400036, 70.32818044240 },
|
|
{ 0.00002051219, 1.51773566586, 0.11187458460 },
|
|
{ 0.00002148602, 0.60745949945, 38.13303563780 },
|
|
{ 0.00001991643, 4.92437588682, 277.03499374140 },
|
|
{ 0.00001376226, 2.04283539351, 65.22037101170 },
|
|
{ 0.00001666902, 3.62744066769, 380.12776796000 },
|
|
{ 0.00001284107, 3.11347961505, 202.25339517410 },
|
|
{ 0.00001150429, 0.93343589092, 3.18139373770 },
|
|
{ 0.00001533221, 2.58594681212, 52.69019803950 },
|
|
{ 0.00001281604, 0.54271272721, 222.86032299360 },
|
|
{ 0.00001372139, 4.19641530878, 111.43016149680 },
|
|
{ 0.00001221029, 0.19900650030, 108.46121608020 },
|
|
{ 0.00000946181, 1.19253165736, 127.47179660680 },
|
|
{ 0.00001150989, 4.17898916639, 33.67961751290 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lon_Uranus_1[] =
|
|
{
|
|
{ 74.78159860910, 0.00000000000, 0.00000000000 },
|
|
{ 0.00154332863, 5.24158770553, 74.78159856730 },
|
|
{ 0.00024456474, 1.71260334156, 1.48447270830 },
|
|
{ 0.00009258442, 0.42829732350, 11.04570026390 },
|
|
{ 0.00008265977, 1.50218091379, 63.73589830340 },
|
|
{ 0.00009150160, 1.41213765216, 149.56319713460 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_lon_Uranus[] =
|
|
{
|
|
{ 39, vsop_lon_Uranus_0 },
|
|
{ 6, vsop_lon_Uranus_1 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lat_Uranus_0[] =
|
|
{
|
|
{ 0.01346277648, 2.61877810547, 74.78159856730 },
|
|
{ 0.00062341400, 5.08111189648, 149.56319713460 },
|
|
{ 0.00061601196, 3.14159265359, 0.00000000000 },
|
|
{ 0.00009963722, 1.61603805646, 76.26607127560 },
|
|
{ 0.00009926160, 0.57630380333, 73.29712585900 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lat_Uranus_1[] =
|
|
{
|
|
{ 0.00034101978, 0.01321929936, 74.78159856730 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_lat_Uranus[] =
|
|
{
|
|
{ 5, vsop_lat_Uranus_0 },
|
|
{ 1, vsop_lat_Uranus_1 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_rad_Uranus_0[] =
|
|
{
|
|
{ 19.21264847206, 0.00000000000, 0.00000000000 },
|
|
{ 0.88784984413, 5.60377527014, 74.78159856730 },
|
|
{ 0.03440836062, 0.32836099706, 73.29712585900 },
|
|
{ 0.02055653860, 1.78295159330, 149.56319713460 },
|
|
{ 0.00649322410, 4.52247285911, 76.26607127560 },
|
|
{ 0.00602247865, 3.86003823674, 63.73589830340 },
|
|
{ 0.00496404167, 1.40139935333, 454.90936652730 },
|
|
{ 0.00338525369, 1.58002770318, 138.51749687070 },
|
|
{ 0.00243509114, 1.57086606044, 71.81265315070 },
|
|
{ 0.00190522303, 1.99809394714, 1.48447270830 },
|
|
{ 0.00161858838, 2.79137786799, 148.07872442630 },
|
|
{ 0.00143706183, 1.38368544947, 11.04570026390 },
|
|
{ 0.00093192405, 0.17437220467, 36.64856292950 },
|
|
{ 0.00071424548, 4.24509236074, 224.34479570190 },
|
|
{ 0.00089806014, 3.66105364565, 109.94568878850 },
|
|
{ 0.00039009723, 1.66971401684, 70.84944530420 },
|
|
{ 0.00046677296, 1.39976401694, 35.16409022120 },
|
|
{ 0.00039025624, 3.36234773834, 277.03499374140 },
|
|
{ 0.00036755274, 3.88649278513, 146.59425171800 },
|
|
{ 0.00030348723, 0.70100838798, 151.04766984290 },
|
|
{ 0.00029156413, 3.18056336700, 77.75054398390 },
|
|
{ 0.00022637073, 0.72518687029, 529.69096509460 },
|
|
{ 0.00011959076, 1.75043392140, 984.60033162190 },
|
|
{ 0.00025620756, 5.25656086672, 380.12776796000 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_rad_Uranus_1[] =
|
|
{
|
|
{ 0.01479896629, 3.67205697578, 74.78159856730 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_rad_Uranus[] =
|
|
{
|
|
{ 24, vsop_rad_Uranus_0 },
|
|
{ 1, vsop_rad_Uranus_1 }
|
|
};
|
|
|
|
;
|
|
static const vsop_term_t vsop_lon_Neptune_0[] =
|
|
{
|
|
{ 5.31188633046, 0.00000000000, 0.00000000000 },
|
|
{ 0.01798475530, 2.90101273890, 38.13303563780 },
|
|
{ 0.01019727652, 0.48580922867, 1.48447270830 },
|
|
{ 0.00124531845, 4.83008090676, 36.64856292950 },
|
|
{ 0.00042064466, 5.41054993053, 2.96894541660 },
|
|
{ 0.00037714584, 6.09221808686, 35.16409022120 },
|
|
{ 0.00033784738, 1.24488874087, 76.26607127560 },
|
|
{ 0.00016482741, 0.00007727998, 491.55792945680 },
|
|
{ 0.00009198584, 4.93747051954, 39.61750834610 },
|
|
{ 0.00008994250, 0.27462171806, 175.16605980020 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lon_Neptune_1[] =
|
|
{
|
|
{ 38.13303563957, 0.00000000000, 0.00000000000 },
|
|
{ 0.00016604172, 4.86323329249, 1.48447270830 },
|
|
{ 0.00015744045, 2.27887427527, 38.13303563780 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_lon_Neptune[] =
|
|
{
|
|
{ 10, vsop_lon_Neptune_0 },
|
|
{ 3, vsop_lon_Neptune_1 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_lat_Neptune_0[] =
|
|
{
|
|
{ 0.03088622933, 1.44104372644, 38.13303563780 },
|
|
{ 0.00027780087, 5.91271884599, 76.26607127560 },
|
|
{ 0.00027623609, 0.00000000000, 0.00000000000 },
|
|
{ 0.00015355489, 2.52123799551, 36.64856292950 },
|
|
{ 0.00015448133, 3.50877079215, 39.61750834610 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_lat_Neptune[] =
|
|
{
|
|
{ 5, vsop_lat_Neptune_0 }
|
|
};
|
|
|
|
static const vsop_term_t vsop_rad_Neptune_0[] =
|
|
{
|
|
{ 30.07013205828, 0.00000000000, 0.00000000000 },
|
|
{ 0.27062259632, 1.32999459377, 38.13303563780 },
|
|
{ 0.01691764014, 3.25186135653, 36.64856292950 },
|
|
{ 0.00807830553, 5.18592878704, 1.48447270830 },
|
|
{ 0.00537760510, 4.52113935896, 35.16409022120 },
|
|
{ 0.00495725141, 1.57105641650, 491.55792945680 },
|
|
{ 0.00274571975, 1.84552258866, 175.16605980020 },
|
|
{ 0.00012012320, 1.92059384991, 1021.24889455140 },
|
|
{ 0.00121801746, 5.79754470298, 76.26607127560 },
|
|
{ 0.00100896068, 0.37702724930, 73.29712585900 },
|
|
{ 0.00135134092, 3.37220609835, 39.61750834610 },
|
|
{ 0.00007571796, 1.07149207335, 388.46515523820 }
|
|
};
|
|
|
|
static const vsop_series_t vsop_rad_Neptune[] =
|
|
{
|
|
{ 12, vsop_rad_Neptune_0 }
|
|
};
|
|
|
|
;
|
|
|
|
/** @cond DOXYGEN_SKIP */
|
|
#define VSOPFORMULA(x) { ARRAYSIZE(x), x }
|
|
/** @endcond */
|
|
|
|
static const vsop_model_t vsop[] =
|
|
{
|
|
{ { VSOPFORMULA(vsop_lon_Mercury), VSOPFORMULA(vsop_lat_Mercury), VSOPFORMULA(vsop_rad_Mercury) } },
|
|
{ { VSOPFORMULA(vsop_lon_Venus), VSOPFORMULA(vsop_lat_Venus), VSOPFORMULA(vsop_rad_Venus) } },
|
|
{ { VSOPFORMULA(vsop_lon_Earth), VSOPFORMULA(vsop_lat_Earth), VSOPFORMULA(vsop_rad_Earth) } },
|
|
{ { VSOPFORMULA(vsop_lon_Mars), VSOPFORMULA(vsop_lat_Mars), VSOPFORMULA(vsop_rad_Mars) } },
|
|
{ { VSOPFORMULA(vsop_lon_Jupiter), VSOPFORMULA(vsop_lat_Jupiter), VSOPFORMULA(vsop_rad_Jupiter) } },
|
|
{ { VSOPFORMULA(vsop_lon_Saturn), VSOPFORMULA(vsop_lat_Saturn), VSOPFORMULA(vsop_rad_Saturn) } },
|
|
{ { VSOPFORMULA(vsop_lon_Uranus), VSOPFORMULA(vsop_lat_Uranus), VSOPFORMULA(vsop_rad_Uranus) } },
|
|
{ { VSOPFORMULA(vsop_lon_Neptune), VSOPFORMULA(vsop_lat_Neptune), VSOPFORMULA(vsop_rad_Neptune) } }
|
|
};
|
|
|
|
/** @cond DOXYGEN_SKIP */
|
|
#define CalcEarth(time) CalcVsop(&vsop[BODY_EARTH], (time))
|
|
#define LON_INDEX 0
|
|
#define LAT_INDEX 1
|
|
#define RAD_INDEX 2
|
|
/** @endcond */
|
|
|
|
static void VsopCoords(const vsop_model_t *model, double t, double sphere[3])
|
|
{
|
|
int k, s, i;
|
|
|
|
for (k=0; k < 3; ++k)
|
|
{
|
|
double tpower = 1.0;
|
|
const vsop_formula_t *formula = &model->formula[k];
|
|
sphere[k] = 0.0;
|
|
for (s=0; s < formula->nseries; ++s)
|
|
{
|
|
double sum = 0.0;
|
|
const vsop_series_t *series = &formula->series[s];
|
|
for (i=0; i < series->nterms; ++i)
|
|
{
|
|
const vsop_term_t *term = &series->term[i];
|
|
sum += term->amplitude * cos(term->phase + (t * term->frequency));
|
|
}
|
|
sphere[k] += tpower * sum;
|
|
tpower *= t;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static terse_vector_t VsopRotate(const double ecl[3])
|
|
{
|
|
terse_vector_t equ;
|
|
|
|
/*
|
|
X +1.000000000000 +0.000000440360 -0.000000190919 X
|
|
Y = -0.000000479966 +0.917482137087 -0.397776982902 Y
|
|
Z FK5 0.000000000000 +0.397776982902 +0.917482137087 Z VSOP87A
|
|
*/
|
|
|
|
equ.x = ecl[0] + 0.000000440360*ecl[1] - 0.000000190919*ecl[2];
|
|
equ.y = -0.000000479966*ecl[0] + 0.917482137087*ecl[1] - 0.397776982902*ecl[2];
|
|
equ.z = 0.397776982902*ecl[1] + 0.917482137087*ecl[2];
|
|
|
|
return equ;
|
|
}
|
|
|
|
|
|
static void VsopSphereToRect(double lon, double lat, double radius, double pos[3])
|
|
{
|
|
double r_coslat = radius * cos(lat);
|
|
pos[0] = r_coslat * cos(lon);
|
|
pos[1] = r_coslat * sin(lon);
|
|
pos[2] = radius * sin(lat);
|
|
}
|
|
|
|
static const double DAYS_PER_MILLENNIUM = 365250.0;
|
|
|
|
|
|
static astro_vector_t CalcVsop(const vsop_model_t *model, astro_time_t time)
|
|
{
|
|
double t = time.tt / DAYS_PER_MILLENNIUM;
|
|
double sphere[3]; /* lon, lat, rad */
|
|
double eclip[3];
|
|
astro_vector_t vector;
|
|
terse_vector_t pos;
|
|
|
|
/* Calculate the VSOP "B" trigonometric series to obtain ecliptic spherical coordinates. */
|
|
VsopCoords(model, t, sphere);
|
|
|
|
/* Convert ecliptic spherical coordinates to ecliptic Cartesian coordinates. */
|
|
VsopSphereToRect(sphere[LON_INDEX], sphere[LAT_INDEX], sphere[RAD_INDEX], eclip);
|
|
|
|
/* Convert ecliptic Cartesian coordinates to equatorial Cartesian coordinates. */
|
|
pos = VsopRotate(eclip);
|
|
|
|
/* Package the position as astro_vector_t. */
|
|
vector.status = ASTRO_SUCCESS;
|
|
vector.t = time;
|
|
vector.x = pos.x;
|
|
vector.y = pos.y;
|
|
vector.z = pos.z;
|
|
|
|
return vector;
|
|
}
|
|
|
|
|
|
static void VsopDeriv(const vsop_model_t *model, double t, double deriv[3])
|
|
{
|
|
int k, s, i;
|
|
|
|
for (k=0; k < 3; ++k)
|
|
{
|
|
double tpower = 1.0; /* t^s */
|
|
double dpower = 0.0; /* t^(s-1) */
|
|
const vsop_formula_t *formula = &model->formula[k];
|
|
deriv[k] = 0.0;
|
|
for (s=0; s < formula->nseries; ++s)
|
|
{
|
|
double sin_sum = 0.0;
|
|
double cos_sum = 0.0;
|
|
const vsop_series_t *series = &formula->series[s];
|
|
for (i=0; i < series->nterms; ++i)
|
|
{
|
|
const vsop_term_t *term = &series->term[i];
|
|
double angle = term->phase + (t * term->frequency);
|
|
sin_sum += term->amplitude * term->frequency * sin(angle);
|
|
if (s > 0)
|
|
cos_sum += term->amplitude * cos(angle);
|
|
}
|
|
deriv[k] += (s * dpower * cos_sum) - (tpower * sin_sum);
|
|
dpower = tpower;
|
|
tpower *= t;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static body_state_t CalcVsopPosVel(const vsop_model_t *model, double tt)
|
|
{
|
|
body_state_t state;
|
|
double t = tt / DAYS_PER_MILLENNIUM;
|
|
double sphere[3]; /* lon, lat, r */
|
|
double deriv[3]; /* d(lon)/dt, d(lat)/dt, dr/dt */
|
|
double eclip[3];
|
|
double dr_dt, dlat_dt, dlon_dt;
|
|
double r, coslat, coslon, sinlat, sinlon;
|
|
|
|
state.tt = tt;
|
|
VsopCoords(model, t, sphere);
|
|
VsopSphereToRect(sphere[LON_INDEX], sphere[LAT_INDEX], sphere[RAD_INDEX], eclip);
|
|
state.r = VsopRotate(eclip);
|
|
|
|
VsopDeriv(model, t, deriv);
|
|
|
|
/* Use spherical coords and spherical derivatives to calculate */
|
|
/* the velocity vector in rectangular coordinates. */
|
|
|
|
/* Calculate mnemonic variables to help keep the math straight. */
|
|
coslon = cos(sphere[LON_INDEX]);
|
|
sinlon = sin(sphere[LON_INDEX]);
|
|
coslat = cos(sphere[LAT_INDEX]);
|
|
sinlat = sin(sphere[LAT_INDEX]);
|
|
r = sphere[RAD_INDEX];
|
|
dlon_dt = deriv[LON_INDEX];
|
|
dlat_dt = deriv[LAT_INDEX];
|
|
dr_dt = deriv[RAD_INDEX];
|
|
|
|
/* vx = dx/dt */
|
|
eclip[0] = (dr_dt * coslat * coslon) - (r * sinlat * coslon * dlat_dt) - (r * coslat * sinlon * dlon_dt);
|
|
|
|
/* vy = dy/dt */
|
|
eclip[1] = (dr_dt * coslat * sinlon) - (r * sinlat * sinlon * dlat_dt) + (r * coslat * coslon * dlon_dt);
|
|
|
|
/* vz = dz/dt */
|
|
eclip[2] = (dr_dt * sinlat) + (r * coslat * dlat_dt);
|
|
|
|
/* Rotate the velocity vector from ecliptic to equatorial coordinates. */
|
|
state.v = VsopRotate(eclip);
|
|
|
|
/* Convert speed units from [AU/millennium] to [AU/day]. */
|
|
VecScale(&state.v, 1 / DAYS_PER_MILLENNIUM);
|
|
|
|
return state;
|
|
}
|
|
|
|
|
|
static double VsopHelioDistance(const vsop_model_t *model, astro_time_t time)
|
|
{
|
|
int s, i;
|
|
double t = time.tt / DAYS_PER_MILLENNIUM;
|
|
double distance = 0.0;
|
|
double tpower = 1.0;
|
|
const vsop_formula_t *formula = &model->formula[2]; /* [2] is the distance part of the formula */
|
|
|
|
/*
|
|
The caller only wants to know the distance between the planet and the Sun.
|
|
So we only need to calculate the radial component of the spherical coordinates.
|
|
*/
|
|
|
|
for (s=0; s < formula->nseries; ++s)
|
|
{
|
|
double sum = 0.0;
|
|
const vsop_series_t *series = &formula->series[s];
|
|
for (i=0; i < series->nterms; ++i)
|
|
{
|
|
const vsop_term_t *term = &series->term[i];
|
|
sum += term->amplitude * cos(term->phase + (t * term->frequency));
|
|
}
|
|
distance += tpower * sum;
|
|
tpower *= t;
|
|
}
|
|
|
|
return distance;
|
|
}
|
|
|
|
|
|
static void AdjustBarycenter(astro_vector_t *ssb, astro_time_t time, astro_body_t body, double planet_gm)
|
|
{
|
|
astro_vector_t planet;
|
|
double shift;
|
|
|
|
shift = planet_gm / (planet_gm + SUN_GM);
|
|
planet = CalcVsop(&vsop[body], time);
|
|
ssb->x += shift * planet.x;
|
|
ssb->y += shift * planet.y;
|
|
ssb->z += shift * planet.z;
|
|
}
|
|
|
|
|
|
static astro_vector_t CalcSolarSystemBarycenter(astro_time_t time)
|
|
{
|
|
astro_vector_t ssb;
|
|
|
|
ssb.status = ASTRO_SUCCESS;
|
|
ssb.t = time;
|
|
ssb.x = ssb.y = ssb.z = 0.0;
|
|
|
|
AdjustBarycenter(&ssb, time, BODY_JUPITER, JUPITER_GM);
|
|
AdjustBarycenter(&ssb, time, BODY_SATURN, SATURN_GM);
|
|
AdjustBarycenter(&ssb, time, BODY_URANUS, URANUS_GM);
|
|
AdjustBarycenter(&ssb, time, BODY_NEPTUNE, NEPTUNE_GM);
|
|
|
|
return ssb;
|
|
}
|
|
|
|
/*------------------ begin Pluto integrator ------------------*/
|
|
|
|
/** @cond DOXYGEN_SKIP */
|
|
typedef struct
|
|
{
|
|
double tt; /* J2000 terrestrial time [days] */
|
|
terse_vector_t r; /* position [au] */
|
|
terse_vector_t v; /* velocity [au/day] */
|
|
terse_vector_t a; /* acceleration [au/day^2] */
|
|
} body_grav_calc_t;
|
|
/** @endcond */
|
|
|
|
#define PLUTO_NUM_STATES 41
|
|
#define PLUTO_TIME_STEP 36500
|
|
|
|
static const body_state_t PlutoStateTable[] =
|
|
{
|
|
{ -730000.0, {-26.1182072321076, -14.3761681778250, 3.3844025152995}, { 1.6339372163656e-03, -2.7861699588508e-03, -1.3585880229445e-03} }
|
|
, { -693500.0, { 43.6599275018261, 15.7782921408811, -8.2269833881374}, {-2.5043046295860e-04, 2.1163039457238e-03, 7.3466073583102e-04} }
|
|
, { -657000.0, {-17.0086014985033, 33.0590743876420, 15.4080189624259}, {-1.9676551946049e-03, -1.8337707766770e-03, 2.0125441459959e-05} }
|
|
, { -620500.0, { 26.9005106893171, -21.5285596810214, -14.7987712668075}, { 2.2939261196998e-03, 1.7431871970059e-03, -1.4585639832643e-04} }
|
|
, { -584000.0, { 20.2303809506997, 43.2669666571891, 7.3829660919234}, {-1.9754081700585e-03, 5.3457141292226e-04, 7.5929169129793e-04} }
|
|
, { -547500.0, {-22.5571440338751, -19.2958112538447, 0.7806423603826}, { 2.1494578646505e-03, -2.4266772630044e-03, -1.4013084013574e-03} }
|
|
, { -511000.0, { 43.0236236810360, 19.6179542007347, -6.8406553041565}, {-4.7729923671058e-04, 2.0208979483877e-03, 7.7191815992131e-04} }
|
|
, { -474500.0, {-20.4245105862934, 29.5157679318005, 15.3408675727018}, {-1.8003167284198e-03, -2.1025226687937e-03, -1.1262333332859e-04} }
|
|
, { -438000.0, { 30.7746921076872, -18.2366370153037, -14.9455358798963}, { 2.0113162005465e-03, 1.9353827024189e-03, -2.0937793168297e-06} }
|
|
, { -401500.0, { 16.7235440456361, 44.0505598318603, 8.6886113939440}, {-2.0565226049264e-03, 3.2710694138777e-04, 7.2006155046579e-04} }
|
|
, { -365000.0, {-18.4891734360057, -23.1428732331142, -1.6436720878799}, { 2.5524223225832e-03, -2.0035792463879e-03, -1.3910737531294e-03} }
|
|
, { -328500.0, { 42.0853950560734, 22.9742531259520, -5.5131410205412}, {-6.7105845193949e-04, 1.9177289500465e-03, 7.9770011059534e-04} }
|
|
, { -292000.0, {-23.2753639151193, 25.8185142987694, 15.0553815885983}, {-1.6062295460975e-03, -2.3395961498533e-03, -2.4377362639479e-04} }
|
|
, { -255500.0, { 33.9015793210130, -14.9421228983498, -14.8664994855707}, { 1.7455105487563e-03, 2.0655068871494e-03, 1.1695000657630e-04} }
|
|
, { -219000.0, { 13.3770189322702, 44.4442211120183, 9.8260227015847}, {-2.1171882923251e-03, 1.3114714542921e-04, 6.7884578840323e-04} }
|
|
, { -182500.0, {-14.1723844533379, -26.0054690135836, -3.8387026446526}, { 2.8419751785822e-03, -1.5579441656564e-03, -1.3408416711060e-03} }
|
|
, { -146000.0, { 40.9468572586403, 25.9049735920209, -4.2563362404988}, {-8.3652705194051e-04, 1.8129497136404e-03, 8.1564228273060e-04} }
|
|
, { -109500.0, {-25.5839689598009, 22.0699164999425, 14.5902026036780}, {-1.3923977856331e-03, -2.5442249745422e-03, -3.7169906721828e-04} }
|
|
, { -73000.0, { 36.4035708396756, -11.7473067389593, -14.6304139635223}, { 1.5037714418941e-03, 2.1500325702247e-03, 2.1523781242948e-04} }
|
|
, { -36500.0, { 10.2436041239517, 44.5280986402285, 10.8048664487066}, {-2.1615839201823e-03, -5.1418983893534e-05, 6.3687060751430e-04} }
|
|
, { 0.0, { -9.8753695807739, -27.9789262247367, -5.7537118247043}, { 3.0287533248818e-03, -1.1276087003636e-03, -1.2651326732361e-03} }
|
|
, { 36500.0, { 39.7009143866164, 28.4327664903825, -3.0906026170881}, {-9.7720559866138e-04, 1.7121518344796e-03, 8.2822409843551e-04} }
|
|
, { 73000.0, {-27.3620419812795, 18.4265651225706, 13.9975343005914}, {-1.1690934621340e-03, -2.7143131627458e-03, -4.9312695340367e-04} }
|
|
, { 109500.0, { 38.3556091850032, -8.7643800131842, -14.2951819118807}, { 1.2922798115839e-03, 2.2032141141126e-03, 2.9606522103424e-04} }
|
|
, { 146000.0, { 7.3929490279056, 44.3826789515344, 11.6295002148543}, {-2.1932815453830e-03, -2.1751799585364e-04, 5.9556516201114e-04} }
|
|
, { 182500.0, { -5.8649529029432, -29.1987619981354, -7.3502494912123}, { 3.1339384323665e-03, -7.4205968379701e-04, -1.1783357537604e-03} }
|
|
, { 219000.0, { 38.4269476345329, 30.5667598351632, -2.0378379641214}, {-1.0958945370084e-03, 1.6194885149659e-03, 8.3705272532546e-04} }
|
|
, { 255500.0, {-28.6586488201636, 15.0309000931701, 13.3365724093667}, {-9.4611899595408e-04, -2.8506813871559e-03, -6.0508645822989e-04} }
|
|
, { 292000.0, { 39.8319806717528, -6.0784057667647, -13.9098153586562}, { 1.1117769689167e-03, 2.2362097830152e-03, 3.6230548231153e-04} }
|
|
, { 328500.0, { 4.8371523764030, 44.0723119541530, 12.3146147867802}, {-2.2164547537724e-03, -3.6790365636785e-04, 5.5542723844616e-04} }
|
|
, { 365000.0, { -2.2619763759487, -29.8581508706765, -8.6502366418978}, { 3.1821176368396e-03, -4.0915169873994e-04, -1.0895893040652e-03} }
|
|
, { 401500.0, { 37.1576590087419, 32.3528396259588, -1.0950381786229}, {-1.1988412606830e-03, 1.5356290902995e-03, 8.4339118209852e-04} }
|
|
, { 438000.0, {-29.5767402292299, 11.8635359435865, 12.6313230398719}, {-7.2292830060955e-04, -2.9587820140709e-03, -7.0824296450300e-04} }
|
|
, { 474500.0, { 40.9541099577599, -3.6589805945370, -13.4994699563950}, { 9.5387298337127e-04, 2.2572135462477e-03, 4.1826529781128e-04} }
|
|
, { 511000.0, { 2.4859523114116, 43.6181887566155, 12.8914184596699}, {-2.2339745420393e-03, -5.1034757181916e-04, 5.1485330196245e-04} }
|
|
, { 547500.0, { 1.0594791441638, -30.1357921778687, -9.7458684762963}, { 3.1921591684898e-03, -1.1305312796150e-04, -9.9954096945965e-04} }
|
|
, { 584000.0, { 35.8778640130144, 33.8942263660709, -0.2245246362769}, {-1.2941245730845e-03, 1.4560427668319e-03, 8.4762160640137e-04} }
|
|
, { 620500.0, {-30.2026537318923, 8.7794211940578, 11.8609238187578}, {-4.9002221381806e-04, -3.0438768469137e-03, -8.0605935262763e-04} }
|
|
, { 657000.0, { 41.8536204011376, -1.3790965838042, -13.0624345337527}, { 8.0674627557124e-04, 2.2702374399791e-03, 4.6832587475465e-04} }
|
|
, { 693500.0, { 0.2468843977112, 43.0303960481227, 13.3909343344167}, {-2.2436121787266e-03, -6.5238074250728e-04, 4.7172729553196e-04} }
|
|
, { 730000.0, { 4.2432528370899, -30.1182016908248, -10.7074412313491}, { 3.1725847067411e-03, 1.6098461202270e-04, -9.0672150593868e-04} }
|
|
};
|
|
|
|
|
|
static terse_vector_t UpdatePosition(double dt, terse_vector_t r, terse_vector_t v, terse_vector_t a)
|
|
{
|
|
r.x += (v.x + a.x*dt/2) * dt;
|
|
r.y += (v.y + a.y*dt/2) * dt;
|
|
r.z += (v.z + a.z*dt/2) * dt;
|
|
return r;
|
|
}
|
|
|
|
|
|
static body_state_t AdjustBarycenterPosVel(body_state_t *ssb, double tt, astro_body_t body, double planet_gm)
|
|
{
|
|
body_state_t planet;
|
|
double shift;
|
|
|
|
/*
|
|
This function does 2 important things:
|
|
1. Adjusts 'ssb' by the effect of one major body on the Solar System Barycenter.
|
|
2, Returns the heliocentric position of that major body.
|
|
*/
|
|
|
|
shift = planet_gm / (planet_gm + SUN_GM);
|
|
planet = CalcVsopPosVel(&vsop[body], tt);
|
|
VecIncr(&ssb->r, VecMul(shift, planet.r));
|
|
VecIncr(&ssb->v, VecMul(shift, planet.v));
|
|
|
|
return planet;
|
|
}
|
|
|
|
|
|
static void MajorBodyBary(body_state_t bary[5], double tt)
|
|
{
|
|
int p;
|
|
|
|
/* bary[0] starts out receiving the Solar System Barycenter. */
|
|
bary[0].tt = tt;
|
|
bary[0].r = VecZero;
|
|
bary[0].v = VecZero;
|
|
|
|
/* Calculate heliocentric planet positions and SSB. */
|
|
bary[1] = AdjustBarycenterPosVel(&bary[0], tt, BODY_JUPITER, JUPITER_GM);
|
|
bary[2] = AdjustBarycenterPosVel(&bary[0], tt, BODY_SATURN, SATURN_GM);
|
|
bary[3] = AdjustBarycenterPosVel(&bary[0], tt, BODY_URANUS, URANUS_GM);
|
|
bary[4] = AdjustBarycenterPosVel(&bary[0], tt, BODY_NEPTUNE, NEPTUNE_GM);
|
|
|
|
for (p=1; p < 5; ++p)
|
|
{
|
|
/* Convert major body [pos, vel] from heliocentric to barycentric. */
|
|
VecDecr(&bary[p].r, bary[0].r);
|
|
VecDecr(&bary[p].v, bary[0].v);
|
|
}
|
|
|
|
/* Convert heliocentric SSB to barycentric Sun. */
|
|
VecScale(&bary[0].r, -1.0);
|
|
VecScale(&bary[0].v, -1.0);
|
|
}
|
|
|
|
|
|
static void AddAcceleration(terse_vector_t *acc, terse_vector_t small_pos, double gm, terse_vector_t major_pos)
|
|
{
|
|
double dx, dy, dz, r2, pull;
|
|
|
|
dx = major_pos.x - small_pos.x;
|
|
dy = major_pos.y - small_pos.y;
|
|
dz = major_pos.z - small_pos.z;
|
|
|
|
r2 = dx*dx + dy*dy + dz*dz;
|
|
pull = gm / (r2 * sqrt(r2));
|
|
|
|
acc->x += dx * pull;
|
|
acc->y += dy * pull;
|
|
acc->z += dz * pull;
|
|
}
|
|
|
|
|
|
static terse_vector_t SmallBodyAcceleration(terse_vector_t small_pos, const body_state_t bary[5])
|
|
{
|
|
terse_vector_t acc = VecZero;
|
|
|
|
/* Use barycentric coordinates of the Sun and major planets to calculate gravitational accelerations. */
|
|
AddAcceleration(&acc, small_pos, SUN_GM, bary[0].r);
|
|
AddAcceleration(&acc, small_pos, JUPITER_GM, bary[1].r);
|
|
AddAcceleration(&acc, small_pos, SATURN_GM, bary[2].r);
|
|
AddAcceleration(&acc, small_pos, URANUS_GM, bary[3].r);
|
|
AddAcceleration(&acc, small_pos, NEPTUNE_GM, bary[4].r);
|
|
|
|
return acc;
|
|
}
|
|
|
|
|
|
body_grav_calc_t GravSim( /* out: [pos, vel, acc] of the simulated body at time tt2 */
|
|
body_state_t bary2[5], /* out: major body barycentric positions at tt2 */
|
|
double tt2, /* in: a target time to be calculated (either before or after tt1 */
|
|
const body_grav_calc_t *calc1) /* in: [pos, vel, acc] of the simulated body at time tt1 */
|
|
{
|
|
body_grav_calc_t calc2;
|
|
terse_vector_t approx_pos;
|
|
terse_vector_t acc;
|
|
const double dt = tt2 - calc1->tt;
|
|
|
|
/* Calculate where the major bodies (Sun, Jupiter...Neptune) will be at the next time step. */
|
|
MajorBodyBary(bary2, tt2);
|
|
|
|
/* Estimate position of small body as if current acceleration applies across the whole time interval. */
|
|
/* approx_pos = pos1 + vel1*dt + (1/2)acc*dt^2 */
|
|
approx_pos = UpdatePosition(dt, calc1->r, calc1->v, calc1->a);
|
|
|
|
/* Calculate acceleration experienced by small body at approximate next location. */
|
|
acc = SmallBodyAcceleration(approx_pos, bary2);
|
|
|
|
/* Calculate the average acceleration of the endpoints. */
|
|
/* This becomes our estimate of the mean effective acceleration over the whole interval. */
|
|
acc = VecMean(acc, calc1->a);
|
|
|
|
/* Refine the estimates of [pos, vel, acc] at tt2 using the mean acceleration. */
|
|
calc2.r = UpdatePosition(dt, calc1->r, calc1->v, acc);
|
|
calc2.v = VecAdd(calc1->v, VecMul(dt, acc));
|
|
calc2.a = SmallBodyAcceleration(calc2.r, bary2);
|
|
calc2.tt = tt2;
|
|
return calc2;
|
|
}
|
|
|
|
|
|
#define PLUTO_DT 250
|
|
#if PLUTO_TIME_STEP % PLUTO_DT != 0
|
|
#error Invalid combination of Pluto time step, time increment.
|
|
#endif
|
|
|
|
#define PLUTO_NSTEPS ((PLUTO_TIME_STEP / PLUTO_DT) + 1)
|
|
|
|
/** @cond DOXYGEN_SKIP */
|
|
typedef struct
|
|
{
|
|
body_grav_calc_t step[PLUTO_NSTEPS];
|
|
}
|
|
body_segment_t;
|
|
/** @endcond */
|
|
|
|
|
|
/* FIXFIXFIX - Using a global is not thread-safe. Either add thread-locks or change API to accept a cache pointer. */
|
|
static body_segment_t *pluto_cache[PLUTO_NUM_STATES-1];
|
|
|
|
|
|
static int ClampIndex(double frac, int nsteps)
|
|
{
|
|
int index = (int) floor(frac);
|
|
if (index < 0)
|
|
return 0;
|
|
if (index >= nsteps)
|
|
return nsteps-1;
|
|
return index;
|
|
}
|
|
|
|
|
|
static body_grav_calc_t GravFromState(body_state_t bary[5], const body_state_t *state)
|
|
{
|
|
body_grav_calc_t calc;
|
|
|
|
MajorBodyBary(bary, state->tt);
|
|
|
|
calc.tt = state->tt;
|
|
calc.r = VecAdd(state->r, bary[0].r); /* convert heliocentric to barycentric */
|
|
calc.v = VecAdd(state->v, bary[0].v); /* convert heliocentric to barycentric */
|
|
calc.a = SmallBodyAcceleration(calc.r, bary);
|
|
|
|
return calc;
|
|
}
|
|
|
|
|
|
static astro_status_t GetSegment(int *seg_index, body_segment_t *cache[], double tt)
|
|
{
|
|
int i;
|
|
body_segment_t reverse;
|
|
body_segment_t *seg;
|
|
body_state_t bary[5];
|
|
double step_tt, ramp;
|
|
|
|
if (tt < PlutoStateTable[0].tt || tt > PlutoStateTable[PLUTO_NUM_STATES-1].tt)
|
|
{
|
|
/* We don't bother calculating a segment. Let the caller crawl backward/forward to this time. */
|
|
*seg_index = -1;
|
|
return ASTRO_SUCCESS;
|
|
}
|
|
|
|
/* See if we have a segment that straddles the requested time. */
|
|
/* If so, return it. Otherwise, calculate it and return it. */
|
|
|
|
*seg_index = ClampIndex((tt - PlutoStateTable[0].tt) / PLUTO_TIME_STEP, PLUTO_NUM_STATES-1);
|
|
if (cache[*seg_index] == NULL)
|
|
{
|
|
/* Allocate memory for the segment (about 11K each). */
|
|
seg = cache[*seg_index] = calloc(1, sizeof(body_segment_t));
|
|
if (seg == NULL)
|
|
return ASTRO_OUT_OF_MEMORY;
|
|
|
|
/* Calculate the segment. */
|
|
/* Pick the pair of bracketing body states to fill the segment. */
|
|
|
|
/* Each endpoint is exact. */
|
|
seg->step[0] = GravFromState(bary, &PlutoStateTable[*seg_index]);
|
|
seg->step[PLUTO_NSTEPS-1] = GravFromState(bary, &PlutoStateTable[*seg_index + 1]);
|
|
|
|
/* Simulate forwards from the lower time bound. */
|
|
step_tt = seg->step[0].tt;
|
|
for (i=1; i < PLUTO_NSTEPS-1; ++i)
|
|
seg->step[i] = GravSim(bary, step_tt += PLUTO_DT, &seg->step[i-1]);
|
|
|
|
/* Simulate backwards from the upper time bound. */
|
|
step_tt = seg->step[PLUTO_NSTEPS-1].tt;
|
|
reverse.step[PLUTO_NSTEPS-1] = seg->step[PLUTO_NSTEPS-1];
|
|
for (i=PLUTO_NSTEPS-2; i > 0; --i)
|
|
reverse.step[i] = GravSim(bary, step_tt -= PLUTO_DT, &reverse.step[i+1]);
|
|
|
|
/* Fade-mix the two series so that there are no discontinuities. */
|
|
for (i=PLUTO_NSTEPS-2; i > 0; --i)
|
|
{
|
|
ramp = (double)i / (PLUTO_NSTEPS-1);
|
|
seg->step[i].r = VecRamp(seg->step[i].r, reverse.step[i].r, ramp);
|
|
seg->step[i].v = VecRamp(seg->step[i].v, reverse.step[i].v, ramp);
|
|
seg->step[i].a = VecRamp(seg->step[i].a, reverse.step[i].a, ramp);
|
|
}
|
|
}
|
|
|
|
return ASTRO_SUCCESS;
|
|
}
|
|
|
|
|
|
static terse_vector_t CalcPlutoOneWay(body_state_t bary[5], const body_state_t *init_state, double target_tt, double dt)
|
|
{
|
|
body_grav_calc_t calc;
|
|
int i, n;
|
|
|
|
calc = GravFromState(bary, init_state);
|
|
n = (int) ceil((target_tt - calc.tt) / dt);
|
|
for (i=0; i < n; ++i)
|
|
calc = GravSim(bary, (i+1 == n) ? target_tt : (calc.tt + dt), &calc);
|
|
|
|
return calc.r;
|
|
}
|
|
|
|
|
|
static astro_vector_t CalcPluto(astro_time_t time)
|
|
{
|
|
terse_vector_t acc, ra, rb, r;
|
|
body_state_t bary[5];
|
|
const body_segment_t *seg;
|
|
int seg_index, left;
|
|
const body_grav_calc_t *s1;
|
|
const body_grav_calc_t *s2;
|
|
astro_status_t status;
|
|
|
|
status = GetSegment(&seg_index, pluto_cache, time.tt);
|
|
if (status != ASTRO_SUCCESS)
|
|
return VecError(status, time);
|
|
|
|
if (seg_index < 0)
|
|
{
|
|
/* The target time is outside the year range 0000..4000. */
|
|
/* Calculate it by crawling backward from 0000 or forward from 4000. */
|
|
/* FIXFIXFIX - This is super slow. Could optimize this with extra caching if needed. */
|
|
if (time.tt < PlutoStateTable[0].tt)
|
|
r = CalcPlutoOneWay(bary, &PlutoStateTable[0], time.tt, -PLUTO_DT);
|
|
else
|
|
r = CalcPlutoOneWay(bary, &PlutoStateTable[PLUTO_NUM_STATES-1], time.tt, +PLUTO_DT);
|
|
}
|
|
else
|
|
{
|
|
seg = pluto_cache[seg_index];
|
|
left = ClampIndex((time.tt - seg->step[0].tt) / PLUTO_DT, PLUTO_NSTEPS-1);
|
|
s1 = &seg->step[left];
|
|
s2 = &seg->step[left+1];
|
|
|
|
/* Find mean acceleration vector over the interval. */
|
|
acc = VecMean(s1->a, s2->a);
|
|
|
|
/* Use Newtonian mechanics to extrapolate away from t1 in the positive time direction. */
|
|
ra = UpdatePosition(time.tt - s1->tt, s1->r, s1->v, acc);
|
|
|
|
/* Use Newtonian mechanics to extrapolate away from t2 in the negative time direction. */
|
|
rb = UpdatePosition(time.tt - s2->tt, s2->r, s2->v, acc);
|
|
|
|
/* Use fade in/out idea to blend the two position estimates. */
|
|
r = VecRamp(ra, rb, (time.tt - s1->tt)/PLUTO_DT);
|
|
MajorBodyBary(bary, time.tt);
|
|
}
|
|
|
|
/* Convert barycentric coordinates back to heliocentric coordinates. */
|
|
return PublicVec(time, VecSub(r, bary[0].r));
|
|
}
|
|
|
|
/*------------------ end Pluto integrator ------------------*/
|
|
|
|
|
|
/**
|
|
* @brief Calculates heliocentric Cartesian coordinates of a body in the J2000 equatorial system.
|
|
*
|
|
* This function calculates the position of the given celestial body as a vector,
|
|
* using the center of the Sun as the origin. The result is expressed as a Cartesian
|
|
* vector in the J2000 equatorial system: the coordinates are based on the mean equator
|
|
* of the Earth at noon UTC on 1 January 2000.
|
|
*
|
|
* The position is not corrected for light travel time or aberration.
|
|
* This is different from the behavior of #Astronomy_GeoVector.
|
|
*
|
|
* If given an invalid value for `body`, this function will fail. The caller should always check
|
|
* the `status` field inside the returned #astro_vector_t for `ASTRO_SUCCESS` (success)
|
|
* or any other value (failure) before trusting the resulting vector.
|
|
*
|
|
* @param body
|
|
* A body for which to calculate a heliocentric position: the Sun, Moon, any of the planets,
|
|
* the Solar System Barycenter (SSB), or the Earth Moon Barycenter (EMB).
|
|
* @param time The date and time for which to calculate the position.
|
|
* @return A heliocentric position vector of the center of the given body.
|
|
*/
|
|
astro_vector_t Astronomy_HelioVector(astro_body_t body, astro_time_t time)
|
|
{
|
|
astro_vector_t vector, earth;
|
|
|
|
switch (body)
|
|
{
|
|
case BODY_SUN:
|
|
vector.status = ASTRO_SUCCESS;
|
|
vector.x = 0.0;
|
|
vector.y = 0.0;
|
|
vector.z = 0.0;
|
|
vector.t = time;
|
|
return vector;
|
|
|
|
case BODY_MERCURY:
|
|
case BODY_VENUS:
|
|
case BODY_EARTH:
|
|
case BODY_MARS:
|
|
case BODY_JUPITER:
|
|
case BODY_SATURN:
|
|
case BODY_URANUS:
|
|
case BODY_NEPTUNE:
|
|
return CalcVsop(&vsop[body], time);
|
|
|
|
case BODY_PLUTO:
|
|
return CalcPluto(time);
|
|
|
|
case BODY_MOON:
|
|
vector = Astronomy_GeoMoon(time);
|
|
earth = CalcEarth(time);
|
|
vector.x += earth.x;
|
|
vector.y += earth.y;
|
|
vector.z += earth.z;
|
|
return vector;
|
|
|
|
case BODY_EMB:
|
|
vector = Astronomy_GeoMoon(time);
|
|
earth = CalcEarth(time);
|
|
vector.x = earth.x + (vector.x / (1.0 + EARTH_MOON_MASS_RATIO));
|
|
vector.y = earth.y + (vector.y / (1.0 + EARTH_MOON_MASS_RATIO));
|
|
vector.z = earth.z + (vector.z / (1.0 + EARTH_MOON_MASS_RATIO));
|
|
return vector;
|
|
|
|
case BODY_SSB:
|
|
return CalcSolarSystemBarycenter(time);
|
|
|
|
default:
|
|
return VecError(ASTRO_INVALID_BODY, time);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Calculates the distance from a body to the Sun at a given time.
|
|
*
|
|
* Given a date and time, this function calculates the distance between
|
|
* the center of `body` and the center of the Sun.
|
|
* For the planets Mercury through Neptune, this function is significantly
|
|
* more efficient than calling #Astronomy_HelioVector followed by #Astronomy_VectorLength.
|
|
*
|
|
* @param body
|
|
* A body for which to calculate a heliocentric distance: the Sun, Moon, or any of the planets.
|
|
*
|
|
* @param time
|
|
* The date and time for which to calculate the heliocentric distance.
|
|
*
|
|
* @return
|
|
* If successful, an #astro_func_result_t structure whose `status` is `ASTRO_SUCCESS`
|
|
* and whose `value` holds the heliocentric distance in AU.
|
|
* Otherwise, `status` reports an error condition.
|
|
*/
|
|
astro_func_result_t Astronomy_HelioDistance(astro_body_t body, astro_time_t time)
|
|
{
|
|
astro_vector_t vector;
|
|
astro_func_result_t result;
|
|
|
|
switch (body)
|
|
{
|
|
case BODY_SUN:
|
|
result.status = ASTRO_SUCCESS;
|
|
result.value = 0.0;
|
|
return result;
|
|
|
|
case BODY_MERCURY:
|
|
case BODY_VENUS:
|
|
case BODY_EARTH:
|
|
case BODY_MARS:
|
|
case BODY_JUPITER:
|
|
case BODY_SATURN:
|
|
case BODY_URANUS:
|
|
case BODY_NEPTUNE:
|
|
result.status = ASTRO_SUCCESS;
|
|
result.value = VsopHelioDistance(&vsop[body], time);
|
|
return result;
|
|
|
|
default:
|
|
/* For non-VSOP objects, fall back to taking the length of the heliocentric vector. */
|
|
vector = Astronomy_HelioVector(body, time);
|
|
if (vector.status != ASTRO_SUCCESS)
|
|
return FuncError(vector.status);
|
|
result.status = ASTRO_SUCCESS;
|
|
result.value = Astronomy_VectorLength(vector);
|
|
return result;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Calculates geocentric Cartesian coordinates of a body in the J2000 equatorial system.
|
|
*
|
|
* This function calculates the position of the given celestial body as a vector,
|
|
* using the center of the Earth as the origin. The result is expressed as a Cartesian
|
|
* vector in the J2000 equatorial system: the coordinates are based on the mean equator
|
|
* of the Earth at noon UTC on 1 January 2000.
|
|
*
|
|
* If given an invalid value for `body`, this function will fail. The caller should always check
|
|
* the `status` field inside the returned #astro_vector_t for `ASTRO_SUCCESS` (success)
|
|
* or any other value (failure) before trusting the resulting vector.
|
|
*
|
|
* Unlike #Astronomy_HelioVector, this function always corrects for light travel time.
|
|
* This means the position of the body is "back-dated" by the amount of time it takes
|
|
* light to travel from that body to an observer on the Earth.
|
|
*
|
|
* Also, the position can optionally be corrected for
|
|
* [aberration](https://en.wikipedia.org/wiki/Aberration_of_light), an effect
|
|
* causing the apparent direction of the body to be shifted due to transverse
|
|
* movement of the Earth with respect to the rays of light coming from that body.
|
|
*
|
|
* @param body A body for which to calculate a heliocentric position: the Sun, Moon, or any of the planets.
|
|
* @param time The date and time for which to calculate the position.
|
|
* @param aberration `ABERRATION` to correct for aberration, or `NO_ABERRATION` to leave uncorrected.
|
|
* @return A geocentric position vector of the center of the given body.
|
|
*/
|
|
astro_vector_t Astronomy_GeoVector(astro_body_t body, astro_time_t time, astro_aberration_t aberration)
|
|
{
|
|
astro_vector_t vector;
|
|
astro_vector_t earth;
|
|
astro_time_t ltime;
|
|
astro_time_t ltime2;
|
|
double dt;
|
|
int iter;
|
|
|
|
if (aberration != ABERRATION && aberration != NO_ABERRATION)
|
|
return VecError(ASTRO_INVALID_PARAMETER, time);
|
|
|
|
switch (body)
|
|
{
|
|
case BODY_EARTH:
|
|
/* The Earth's geocentric coordinates are always (0,0,0). */
|
|
vector.status = ASTRO_SUCCESS;
|
|
vector.x = 0.0;
|
|
vector.y = 0.0;
|
|
vector.z = 0.0;
|
|
break;
|
|
|
|
case BODY_MOON:
|
|
vector = Astronomy_GeoMoon(time);
|
|
break;
|
|
|
|
default:
|
|
/* For all other bodies, apply light travel time correction. */
|
|
|
|
if (aberration == NO_ABERRATION)
|
|
{
|
|
/* No aberration, so calculate Earth's position once, at the time of observation. */
|
|
earth = CalcEarth(time);
|
|
if (earth.status != ASTRO_SUCCESS)
|
|
return earth;
|
|
}
|
|
|
|
ltime = time;
|
|
for (iter=0; iter < 10; ++iter)
|
|
{
|
|
vector = Astronomy_HelioVector(body, ltime);
|
|
if (vector.status != ASTRO_SUCCESS)
|
|
return vector;
|
|
|
|
if (aberration == ABERRATION)
|
|
{
|
|
/*
|
|
Include aberration, so make a good first-order approximation
|
|
by backdating the Earth's position also.
|
|
This is confusing, but it works for objects within the Solar System
|
|
because the distance the Earth moves in that small amount of light
|
|
travel time (a few minutes to a few hours) is well approximated
|
|
by a line segment that substends the angle seen from the remote
|
|
body viewing Earth. That angle is pretty close to the aberration
|
|
angle of the moving Earth viewing the remote body.
|
|
In other words, both of the following approximate the aberration angle:
|
|
(transverse distance Earth moves) / (distance to body)
|
|
(transverse speed of Earth) / (speed of light).
|
|
*/
|
|
earth = CalcEarth(ltime);
|
|
if (earth.status != ASTRO_SUCCESS)
|
|
return earth;
|
|
}
|
|
|
|
/* Convert heliocentric vector to geocentric vector. */
|
|
vector.x -= earth.x;
|
|
vector.y -= earth.y;
|
|
vector.z -= earth.z;
|
|
|
|
ltime2 = Astronomy_AddDays(time, -Astronomy_VectorLength(vector) / C_AUDAY);
|
|
dt = fabs(ltime2.tt - ltime.tt);
|
|
if (dt < 1.0e-9)
|
|
goto finished; /* Ensures we patch 'vector.t' with current time, not ante-dated time. */
|
|
|
|
ltime = ltime2;
|
|
}
|
|
return VecError(ASTRO_NO_CONVERGE, time); /* light travel time solver did not converge */
|
|
}
|
|
|
|
finished:
|
|
vector.t = time;
|
|
return vector;
|
|
}
|
|
|
|
/**
|
|
* @brief Calculates equatorial coordinates of a celestial body as seen by an observer on the Earth's surface.
|
|
*
|
|
* Calculates topocentric equatorial coordinates in one of two different systems:
|
|
* J2000 or true-equator-of-date, depending on the value of the `equdate` parameter.
|
|
* Equatorial coordinates include right ascension, declination, and distance in astronomical units.
|
|
*
|
|
* This function corrects for light travel time: it adjusts the apparent location
|
|
* of the observed body based on how long it takes for light to travel from the body to the Earth.
|
|
*
|
|
* This function corrects for *topocentric parallax*, meaning that it adjusts for the
|
|
* angular shift depending on where the observer is located on the Earth. This is most
|
|
* significant for the Moon, because it is so close to the Earth. However, parallax corection
|
|
* has a small effect on the apparent positions of other bodies.
|
|
*
|
|
* Correction for aberration is optional, using the `aberration` parameter.
|
|
*
|
|
* @param body The celestial body to be observed. Not allowed to be `BODY_EARTH`.
|
|
* @param time The date and time at which the observation takes place.
|
|
* @param observer A location on or near the surface of the Earth.
|
|
* @param equdate Selects the date of the Earth's equator in which to express the equatorial coordinates.
|
|
* @param aberration Selects whether or not to correct for aberration.
|
|
*/
|
|
astro_equatorial_t Astronomy_Equator(
|
|
astro_body_t body,
|
|
astro_time_t *time,
|
|
astro_observer_t observer,
|
|
astro_equator_date_t equdate,
|
|
astro_aberration_t aberration)
|
|
{
|
|
astro_equatorial_t equ;
|
|
astro_vector_t gc;
|
|
double gc_observer[3];
|
|
double j2000[3];
|
|
double temp[3];
|
|
double datevect[3];
|
|
|
|
geo_pos(time, observer, gc_observer);
|
|
gc = Astronomy_GeoVector(body, *time, aberration);
|
|
if (gc.status != ASTRO_SUCCESS)
|
|
return EquError(gc.status);
|
|
|
|
j2000[0] = gc.x - gc_observer[0];
|
|
j2000[1] = gc.y - gc_observer[1];
|
|
j2000[2] = gc.z - gc_observer[2];
|
|
|
|
switch (equdate)
|
|
{
|
|
case EQUATOR_OF_DATE:
|
|
precession(0.0, j2000, time->tt, temp);
|
|
nutation(time, 0, temp, datevect);
|
|
equ = vector2radec(datevect);
|
|
return equ;
|
|
|
|
case EQUATOR_J2000:
|
|
equ = vector2radec(j2000);
|
|
return equ;
|
|
|
|
default:
|
|
return EquError(ASTRO_INVALID_PARAMETER);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Calculates the apparent location of a body relative to the local horizon of an observer on the Earth.
|
|
*
|
|
* Given a date and time, the geographic location of an observer on the Earth, and
|
|
* equatorial coordinates (right ascension and declination) of a celestial body,
|
|
* this function returns horizontal coordinates (azimuth and altitude angles) for the body
|
|
* relative to the horizon at the geographic location.
|
|
*
|
|
* The right ascension `ra` and declination `dec` passed in must be *equator of date*
|
|
* coordinates, based on the Earth's true equator at the date and time of the observation.
|
|
* Otherwise the resulting horizontal coordinates will be inaccurate.
|
|
* Equator of date coordinates can be obtained by calling #Astronomy_Equator, passing in
|
|
* `EQUATOR_OF_DATE` as its `equdate` parameter. It is also recommended to enable
|
|
* aberration correction by passing in `ABERRATION` as the `aberration` parameter.
|
|
*
|
|
* This function optionally corrects for atmospheric refraction.
|
|
* For most uses, it is recommended to pass `REFRACTION_NORMAL` in the `refraction` parameter to
|
|
* correct for optical lensing of the Earth's atmosphere that causes objects
|
|
* to appear somewhat higher above the horizon than they actually are.
|
|
* However, callers may choose to avoid this correction by passing in `REFRACTION_NONE`.
|
|
* If refraction correction is enabled, the azimuth, altitude, right ascension, and declination
|
|
* in the #astro_horizon_t structure returned by this function will all be corrected for refraction.
|
|
* If refraction is disabled, none of these four coordinates will be corrected; in that case,
|
|
* the right ascension and declination in the returned structure will be numerically identical
|
|
* to the respective `ra` and `dec` values passed in.
|
|
*
|
|
* @param time
|
|
* The date and time of the observation.
|
|
*
|
|
* @param observer
|
|
* The geographic location of the observer.
|
|
*
|
|
* @param ra
|
|
* The right ascension of the body in sidereal hours.
|
|
* See function remarks for more details.
|
|
*
|
|
* @param dec
|
|
* The declination of the body in degrees. See function remarks for more details.
|
|
*
|
|
* @param refraction
|
|
* Selects whether to correct for atmospheric refraction, and if so, which model to use.
|
|
* The recommended value for most uses is `REFRACTION_NORMAL`.
|
|
* See function remarks for more details.
|
|
*
|
|
* @return
|
|
* The body's apparent horizontal coordinates and equatorial coordinates, both optionally corrected for refraction.
|
|
*/
|
|
astro_horizon_t Astronomy_Horizon(
|
|
astro_time_t *time, astro_observer_t observer, double ra, double dec, astro_refraction_t refraction)
|
|
{
|
|
astro_horizon_t hor;
|
|
double uze[3], une[3], uwe[3];
|
|
double uz[3], un[3], uw[3];
|
|
double p[3], pz, pn, pw, proj;
|
|
double az, zd;
|
|
double spin_angle;
|
|
|
|
double sinlat = sin(observer.latitude * DEG2RAD);
|
|
double coslat = cos(observer.latitude * DEG2RAD);
|
|
double sinlon = sin(observer.longitude * DEG2RAD);
|
|
double coslon = cos(observer.longitude * DEG2RAD);
|
|
double sindc = sin(dec * DEG2RAD);
|
|
double cosdc = cos(dec * DEG2RAD);
|
|
double sinra = sin(ra * 15 * DEG2RAD);
|
|
double cosra = cos(ra * 15 * DEG2RAD);
|
|
|
|
uze[0] = coslat * coslon;
|
|
uze[1] = coslat * sinlon;
|
|
uze[2] = sinlat;
|
|
|
|
une[0] = -sinlat * coslon;
|
|
une[1] = -sinlat * sinlon;
|
|
une[2] = coslat;
|
|
|
|
uwe[0] = sinlon;
|
|
uwe[1] = -coslon;
|
|
uwe[2] = 0.0;
|
|
|
|
spin_angle = -15.0 * sidereal_time(time);
|
|
spin(spin_angle, uze, uz);
|
|
spin(spin_angle, une, un);
|
|
spin(spin_angle, uwe, uw);
|
|
|
|
p[0] = cosdc * cosra;
|
|
p[1] = cosdc * sinra;
|
|
p[2] = sindc;
|
|
|
|
pz = p[0]*uz[0] + p[1]*uz[1] + p[2]*uz[2];
|
|
pn = p[0]*un[0] + p[1]*un[1] + p[2]*un[2];
|
|
pw = p[0]*uw[0] + p[1]*uw[1] + p[2]*uw[2];
|
|
|
|
proj = sqrt(pn*pn + pw*pw);
|
|
az = 0.0;
|
|
if (proj > 0.0)
|
|
{
|
|
az = -atan2(pw, pn) * RAD2DEG;
|
|
if (az < 0)
|
|
az += 360;
|
|
else if (az >= 360)
|
|
az -= 360;
|
|
}
|
|
zd = atan2(proj, pz) * RAD2DEG;
|
|
hor.ra = ra;
|
|
hor.dec = dec;
|
|
|
|
if (refraction == REFRACTION_NORMAL || refraction == REFRACTION_JPLHOR)
|
|
{
|
|
double zd0, refr;
|
|
|
|
zd0 = zd;
|
|
refr = Astronomy_Refraction(refraction, 90.0 - zd);
|
|
zd -= refr;
|
|
|
|
if (refr > 0.0 && zd > 3.0e-4)
|
|
{
|
|
int j;
|
|
double sinzd = sin(zd * DEG2RAD);
|
|
double coszd = cos(zd * DEG2RAD);
|
|
double sinzd0 = sin(zd0 * DEG2RAD);
|
|
double coszd0 = cos(zd0 * DEG2RAD);
|
|
double pr[3];
|
|
|
|
for (j=0; j<3; ++j)
|
|
pr[j] = ((p[j] - coszd0 * uz[j]) / sinzd0)*sinzd + uz[j]*coszd;
|
|
|
|
proj = sqrt(pr[0]*pr[0] + pr[1]*pr[1]);
|
|
if (proj > 0)
|
|
{
|
|
hor.ra = atan2(pr[1], pr[0]) * (RAD2DEG / 15.0);
|
|
if (hor.ra < 0.0)
|
|
hor.ra += 24.0;
|
|
else if (hor.ra >= 24.0)
|
|
hor.ra -= 24.0;
|
|
}
|
|
else
|
|
{
|
|
hor.ra = 0.0;
|
|
}
|
|
hor.dec = atan2(pr[2], proj) * RAD2DEG;
|
|
}
|
|
}
|
|
|
|
hor.azimuth = az;
|
|
hor.altitude = 90.0 - zd;
|
|
return hor;
|
|
}
|
|
|
|
/**
|
|
* @brief Calculates geocentric ecliptic coordinates for the Sun.
|
|
*
|
|
* This function calculates the position of the Sun as seen from the Earth.
|
|
* The returned value includes both Cartesian and spherical coordinates.
|
|
* The x-coordinate and longitude values in the returned structure are based
|
|
* on the *true equinox of date*: one of two points in the sky where the instantaneous
|
|
* plane of the Earth's equator at the given date and time (the *equatorial plane*)
|
|
* intersects with the plane of the Earth's orbit around the Sun (the *ecliptic plane*).
|
|
* By convention, the apparent location of the Sun at the March equinox is chosen
|
|
* as the longitude origin and x-axis direction, instead of the one for September.
|
|
*
|
|
* `Astronomy_SunPosition` corrects for precession and nutation of the Earth's axis
|
|
* in order to obtain the exact equatorial plane at the given time.
|
|
*
|
|
* This function can be used for calculating changes of seasons: equinoxes and solstices.
|
|
* In fact, the function #Astronomy_Seasons does use this function for that purpose.
|
|
*
|
|
* @param time
|
|
* The date and time for which to calculate the Sun's position.
|
|
*
|
|
* @return
|
|
* The ecliptic coordinates of the Sun using the Earth's true equator of date.
|
|
*/
|
|
astro_ecliptic_t Astronomy_SunPosition(astro_time_t time)
|
|
{
|
|
astro_time_t adjusted_time;
|
|
astro_vector_t earth2000;
|
|
double sun2000[3];
|
|
double stemp[3];
|
|
double sun_ofdate[3];
|
|
double true_obliq;
|
|
|
|
/* Correct for light travel time from the Sun. */
|
|
/* Otherwise season calculations (equinox, solstice) will all be early by about 8 minutes! */
|
|
adjusted_time = Astronomy_AddDays(time, -1.0 / C_AUDAY);
|
|
|
|
earth2000 = CalcEarth(adjusted_time);
|
|
if (earth2000.status != ASTRO_SUCCESS)
|
|
return EclError(earth2000.status);
|
|
|
|
/* Convert heliocentric location of Earth to geocentric location of Sun. */
|
|
sun2000[0] = -earth2000.x;
|
|
sun2000[1] = -earth2000.y;
|
|
sun2000[2] = -earth2000.z;
|
|
|
|
/* Convert to equatorial Cartesian coordinates of date. */
|
|
precession(0.0, sun2000, adjusted_time.tt, stemp);
|
|
nutation(&adjusted_time, 0, stemp, sun_ofdate);
|
|
|
|
/* Convert equatorial coordinates to ecliptic coordinates. */
|
|
true_obliq = DEG2RAD * e_tilt(&adjusted_time).tobl;
|
|
return RotateEquatorialToEcliptic(sun_ofdate, true_obliq);
|
|
}
|
|
|
|
/**
|
|
* @brief Converts J2000 equatorial Cartesian coordinates to J2000 ecliptic coordinates.
|
|
*
|
|
* Given coordinates relative to the Earth's equator at J2000 (the instant of noon UTC
|
|
* on 1 January 2000), this function converts those coordinates to J2000 ecliptic coordinates,
|
|
* which are relative to the plane of the Earth's orbit around the Sun.
|
|
*
|
|
* @param equ
|
|
* Equatorial coordinates in the J2000 frame of reference.
|
|
* You can call #Astronomy_GeoVector to obtain suitable equatorial coordinates.
|
|
*
|
|
* @return
|
|
* Ecliptic coordinates in the J2000 frame of reference.
|
|
*/
|
|
astro_ecliptic_t Astronomy_Ecliptic(astro_vector_t equ)
|
|
{
|
|
/* Based on NOVAS functions equ2ecl() and equ2ecl_vec(). */
|
|
static const double ob2000 = 0.40909260059599012; /* mean obliquity of the J2000 ecliptic in radians */
|
|
double pos[3];
|
|
|
|
if (equ.status != ASTRO_SUCCESS)
|
|
return EclError(equ.status);
|
|
|
|
pos[0] = equ.x;
|
|
pos[1] = equ.y;
|
|
pos[2] = equ.z;
|
|
|
|
return RotateEquatorialToEcliptic(pos, ob2000);
|
|
}
|
|
|
|
/**
|
|
* @brief Calculates heliocentric ecliptic longitude of a body based on the J2000 equinox.
|
|
*
|
|
* This function calculates the angle around the plane of the Earth's orbit
|
|
* of a celestial body, as seen from the center of the Sun.
|
|
* The angle is measured prograde (in the direction of the Earth's orbit around the Sun)
|
|
* in degrees from the J2000 equinox. The ecliptic longitude is always in the range [0, 360).
|
|
*
|
|
* @param body
|
|
* A body other than the Sun.
|
|
*
|
|
* @param time
|
|
* The date and time at which the body's ecliptic longitude is to be calculated.
|
|
*
|
|
* @return
|
|
* On success, returns a structure whose `status` is `ASTRO_SUCCESS` and whose
|
|
* `angle` holds the ecliptic longitude in degrees.
|
|
* On failure, `status` holds a value other than `ASTRO_SUCCESS`.
|
|
*/
|
|
astro_angle_result_t Astronomy_EclipticLongitude(astro_body_t body, astro_time_t time)
|
|
{
|
|
astro_vector_t hv;
|
|
astro_ecliptic_t eclip;
|
|
astro_angle_result_t result;
|
|
|
|
if (body == BODY_SUN)
|
|
return AngleError(ASTRO_INVALID_BODY); /* cannot calculate heliocentric longitude of the Sun */
|
|
|
|
hv = Astronomy_HelioVector(body, time);
|
|
eclip = Astronomy_Ecliptic(hv); /* checks for errors in hv, so we don't have to here */
|
|
if (eclip.status != ASTRO_SUCCESS)
|
|
return AngleError(eclip.status);
|
|
|
|
result.angle = eclip.elon;
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
static astro_ecliptic_t RotateEquatorialToEcliptic(const double pos[3], double obliq_radians)
|
|
{
|
|
astro_ecliptic_t ecl;
|
|
double cos_ob, sin_ob;
|
|
double xyproj;
|
|
|
|
cos_ob = cos(obliq_radians);
|
|
sin_ob = sin(obliq_radians);
|
|
|
|
ecl.ex = +pos[0];
|
|
ecl.ey = +pos[1]*cos_ob + pos[2]*sin_ob;
|
|
ecl.ez = -pos[1]*sin_ob + pos[2]*cos_ob;
|
|
|
|
xyproj = sqrt(ecl.ex*ecl.ex + ecl.ey*ecl.ey);
|
|
if (xyproj > 0.0)
|
|
{
|
|
ecl.elon = RAD2DEG * atan2(ecl.ey, ecl.ex);
|
|
if (ecl.elon < 0.0)
|
|
ecl.elon += 360.0;
|
|
}
|
|
else
|
|
ecl.elon = 0.0;
|
|
|
|
ecl.elat = RAD2DEG * atan2(ecl.ez, xyproj);
|
|
ecl.status = ASTRO_SUCCESS;
|
|
return ecl;
|
|
}
|
|
|
|
static astro_func_result_t sun_offset(void *context, astro_time_t time)
|
|
{
|
|
astro_func_result_t result;
|
|
double targetLon = *((double *)context);
|
|
astro_ecliptic_t ecl = Astronomy_SunPosition(time);
|
|
if (ecl.status != ASTRO_SUCCESS)
|
|
return FuncError(ecl.status);
|
|
result.value = LongitudeOffset(ecl.elon - targetLon);
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Searches for the time when the Sun reaches an apparent ecliptic longitude as seen from the Earth.
|
|
*
|
|
* This function finds the moment in time, if any exists in the given time window,
|
|
* that the center of the Sun reaches a specific ecliptic longitude as seen from the center of the Earth.
|
|
*
|
|
* This function can be used to determine equinoxes and solstices.
|
|
* However, it is usually more convenient and efficient to call #Astronomy_Seasons
|
|
* to calculate all equinoxes and solstices for a given calendar year.
|
|
*
|
|
* The function searches the window of time specified by `startTime` and `startTime+limitDays`.
|
|
* The search will return an error if the Sun never reaches the longitude `targetLon` or
|
|
* if the window is so large that the longitude ranges more than 180 degrees within it.
|
|
* It is recommended to keep the window smaller than 10 days when possible.
|
|
*
|
|
* @param targetLon
|
|
* The desired ecliptic longitude in degrees, relative to the true equinox of date.
|
|
* This may be any value in the range [0, 360), although certain values have
|
|
* conventional meanings:
|
|
* 0 = March equinox, 90 = June solstice, 180 = September equinox, 270 = December solstice.
|
|
*
|
|
* @param startTime
|
|
* The date and time for starting the search for the desired longitude event.
|
|
*
|
|
* @param limitDays
|
|
* The real-valued number of days, which when added to `startTime`, limits the
|
|
* range of time over which the search looks.
|
|
* It is recommended to keep this value between 1 and 10 days.
|
|
* See function remarks for more details.
|
|
*
|
|
* @return
|
|
* If successful, the `status` field in the returned structure will contain `ASTRO_SUCCESS`
|
|
* and the `time` field will contain the date and time the Sun reaches the target longitude.
|
|
* Any other value indicates an error.
|
|
* See remarks in #Astronomy_Search (which this function calls) for more information about possible error codes.
|
|
*/
|
|
astro_search_result_t Astronomy_SearchSunLongitude(
|
|
double targetLon,
|
|
astro_time_t startTime,
|
|
double limitDays)
|
|
{
|
|
astro_time_t t2 = Astronomy_AddDays(startTime, limitDays);
|
|
return Astronomy_Search(sun_offset, &targetLon, startTime, t2, 1.0);
|
|
}
|
|
|
|
/** @cond DOXYGEN_SKIP */
|
|
#define CALLFUNC(f,t) \
|
|
do { \
|
|
funcres = func(context, (t)); \
|
|
if (funcres.status != ASTRO_SUCCESS) return SearchError(funcres.status); \
|
|
(f) = funcres.value; \
|
|
} while(0)
|
|
/** @endcond */
|
|
|
|
/**
|
|
* @brief Searches for a time at which a function's value increases through zero.
|
|
*
|
|
* Certain astronomy calculations involve finding a time when an event occurs.
|
|
* Often such events can be defined as the root of a function:
|
|
* the time at which the function's value becomes zero.
|
|
*
|
|
* `Astronomy_Search` finds the *ascending root* of a function: the time at which
|
|
* the function's value becomes zero while having a positive slope. That is, as time increases,
|
|
* the function transitions from a negative value, through zero at a specific moment,
|
|
* to a positive value later. The goal of the search is to find that specific moment.
|
|
*
|
|
* The search function is specified by two parameters: `func` and `context`.
|
|
* The `func` parameter is a pointer to the function itself, which accepts a time
|
|
* and a context containing any other arguments needed to evaluate the function.
|
|
* The `context` parameter supplies that context for the given search.
|
|
* As an example, a caller may wish to find the moment a celestial body reaches a certain
|
|
* ecliptic longitude. In that case, the caller might create a structure that contains
|
|
* an #astro_body_t member to specify the body and a `double` to hold the target longitude.
|
|
* The function would cast the pointer `context` passed in as a pointer to that structure type.
|
|
* It could subtract the target longitude from the actual longitude at a given time;
|
|
* thus the difference would equal zero at the moment in time the planet reaches the
|
|
* desired longitude.
|
|
*
|
|
* The `func` returns an #astro_func_result_t structure every time it is called.
|
|
* If the returned structure has a value of `status` other than `ASTRO_SUCCESS`,
|
|
* the search immediately fails and reports that same error code in the `status`
|
|
* returned by `Astronomy_Search`. Otherwise, `status` is `ASTRO_SUCCESS` and
|
|
* `value` is the value of the function, and the search proceeds until it either
|
|
* finds the ascending root or fails for some reason.
|
|
*
|
|
* The search calls `func` repeatedly to rapidly narrow in on any ascending
|
|
* root within the time window specified by `t1` and `t2`. The search never
|
|
* reports a solution outside this time window.
|
|
*
|
|
* `Astronomy_Search` uses a combination of bisection and quadratic interpolation
|
|
* to minimize the number of function calls. However, it is critical that the
|
|
* supplied time window be small enough that there cannot be more than one root
|
|
* (ascedning or descending) within it; otherwise the search can fail.
|
|
* Beyond that, it helps to make the time window as small as possible, ideally
|
|
* such that the function itself resembles a smooth parabolic curve within that window.
|
|
*
|
|
* If an ascending root is not found, or more than one root
|
|
* (ascending and/or descending) exists within the window `t1`..`t2`,
|
|
* the search will fail with status code `ASTRO_SEARCH_FAILURE`.
|
|
*
|
|
* If the search does not converge within 20 iterations, it will fail
|
|
* with status code `ASTRO_NO_CONVERGE`.
|
|
*
|
|
* @param func
|
|
* The function for which to find the time of an ascending root.
|
|
* See function remarks for more details.
|
|
*
|
|
* @param context
|
|
* Any ancillary data needed by the function `func` to calculate a value.
|
|
* The data type varies depending on the function passed in.
|
|
* For example, the function may involve a specific celestial body that
|
|
* must be specified somehow.
|
|
*
|
|
* @param t1
|
|
* The lower time bound of the search window.
|
|
* See function remarks for more details.
|
|
*
|
|
* @param t2
|
|
* The upper time bound of the search window.
|
|
* See function remarks for more details.
|
|
*
|
|
* @param dt_tolerance_seconds
|
|
* Specifies an amount of time in seconds within which a bounded ascending root
|
|
* is considered accurate enough to stop. A typical value is 1 second.
|
|
*
|
|
* @return
|
|
* If successful, the returned structure has `status` equal to `ASTRO_SUCCESS`
|
|
* and `time` set to a value within `dt_tolerance_seconds` of an ascending root.
|
|
* On success, the `time` value will always be in the inclusive range [`t1`, `t2`].
|
|
* If the search fails, `status` will be set to a value other than `ASTRO_SUCCESS`.
|
|
* See function remarks for more details.
|
|
*/
|
|
astro_search_result_t Astronomy_Search(
|
|
astro_search_func_t func,
|
|
void *context,
|
|
astro_time_t t1,
|
|
astro_time_t t2,
|
|
double dt_tolerance_seconds)
|
|
{
|
|
astro_search_result_t result;
|
|
astro_time_t tmid;
|
|
astro_time_t tq;
|
|
astro_func_result_t funcres;
|
|
double f1, f2, fmid=0.0, fq, dt_days, dt, dt_guess;
|
|
double q_x, q_ut, q_df_dt;
|
|
const int iter_limit = 20;
|
|
int iter = 0;
|
|
int calc_fmid = 1;
|
|
|
|
dt_days = fabs(dt_tolerance_seconds / SECONDS_PER_DAY);
|
|
CALLFUNC(f1, t1);
|
|
CALLFUNC(f2, t2);
|
|
|
|
for(;;)
|
|
{
|
|
if (++iter > iter_limit)
|
|
return SearchError(ASTRO_NO_CONVERGE);
|
|
|
|
dt = (t2.tt - t1.tt) / 2.0;
|
|
tmid = Astronomy_AddDays(t1, dt);
|
|
if (fabs(dt) < dt_days)
|
|
{
|
|
/* We are close enough to the event to stop the search. */
|
|
result.time = tmid;
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
if (calc_fmid)
|
|
CALLFUNC(fmid, tmid);
|
|
else
|
|
calc_fmid = 1; /* we already have the correct value of fmid from the previous loop */
|
|
|
|
/* Quadratic interpolation: */
|
|
/* Try to find a parabola that passes through the 3 points we have sampled: */
|
|
/* (t1,f1), (tmid,fmid), (t2,f2) */
|
|
|
|
if (QuadInterp(tmid.ut, t2.ut - tmid.ut, f1, fmid, f2, &q_x, &q_ut, &q_df_dt))
|
|
{
|
|
tq = Astronomy_TimeFromDays(q_ut);
|
|
CALLFUNC(fq, tq);
|
|
if (q_df_dt != 0.0)
|
|
{
|
|
dt_guess = fabs(fq / q_df_dt);
|
|
if (dt_guess < dt_days)
|
|
{
|
|
/* The estimated time error is small enough that we can quit now. */
|
|
result.time = tq;
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
/* Try guessing a tighter boundary with the interpolated root at the center. */
|
|
dt_guess *= 1.2;
|
|
if (dt_guess < dt/10.0)
|
|
{
|
|
astro_time_t tleft = Astronomy_AddDays(tq, -dt_guess);
|
|
astro_time_t tright = Astronomy_AddDays(tq, +dt_guess);
|
|
if ((tleft.ut - t1.ut)*(tleft.ut - t2.ut) < 0)
|
|
{
|
|
if ((tright.ut - t1.ut)*(tright.ut - t2.ut) < 0)
|
|
{
|
|
double fleft, fright;
|
|
CALLFUNC(fleft, tleft);
|
|
CALLFUNC(fright, tright);
|
|
if (fleft<0.0 && fright>=0.0)
|
|
{
|
|
f1 = fleft;
|
|
f2 = fright;
|
|
t1 = tleft;
|
|
t2 = tright;
|
|
fmid = fq;
|
|
calc_fmid = 0; /* save a little work -- no need to re-calculate fmid next time around the loop */
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* After quadratic interpolation attempt. */
|
|
/* Now just divide the region in two parts and pick whichever one appears to contain a root. */
|
|
if (f1 < 0.0 && fmid >= 0.0)
|
|
{
|
|
t2 = tmid;
|
|
f2 = fmid;
|
|
continue;
|
|
}
|
|
|
|
if (fmid < 0.0 && f2 >= 0.0)
|
|
{
|
|
t1 = tmid;
|
|
f1 = fmid;
|
|
continue;
|
|
}
|
|
|
|
/* Either there is no ascending zero-crossing in this range */
|
|
/* or the search window is too wide (more than one zero-crossing). */
|
|
return SearchError(ASTRO_SEARCH_FAILURE);
|
|
}
|
|
}
|
|
|
|
static int QuadInterp(
|
|
double tm, double dt, double fa, double fm, double fb,
|
|
double *out_x, double *out_t, double *out_df_dt)
|
|
{
|
|
double Q, R, S;
|
|
double u, ru, x1, x2;
|
|
|
|
Q = (fb + fa)/2.0 - fm;
|
|
R = (fb - fa)/2.0;
|
|
S = fm;
|
|
|
|
if (Q == 0.0)
|
|
{
|
|
/* This is a line, not a parabola. */
|
|
if (R == 0.0)
|
|
return 0; /* This is a HORIZONTAL line... can't make progress! */
|
|
*out_x = -S / R;
|
|
if (*out_x < -1.0 || *out_x > +1.0)
|
|
return 0; /* out of bounds */
|
|
}
|
|
else
|
|
{
|
|
/* This really is a parabola. Find roots x1, x2. */
|
|
u = R*R - 4*Q*S;
|
|
if (u <= 0.0)
|
|
return 0; /* can't solve if imaginary, or if vertex of parabola is tangent. */
|
|
|
|
ru = sqrt(u);
|
|
x1 = (-R + ru) / (2.0 * Q);
|
|
x2 = (-R - ru) / (2.0 * Q);
|
|
if (-1.0 <= x1 && x1 <= +1.0)
|
|
{
|
|
if (-1.0 <= x2 && x2 <= +1.0)
|
|
return 0; /* two roots are within bounds; we require a unique zero-crossing. */
|
|
*out_x = x1;
|
|
}
|
|
else if (-1.0 <= x2 && x2 <= +1.0)
|
|
*out_x = x2;
|
|
else
|
|
return 0; /* neither root is within bounds */
|
|
}
|
|
|
|
*out_t = tm + (*out_x)*dt;
|
|
*out_df_dt = (2*Q*(*out_x) + R) / dt;
|
|
return 1; /* success */
|
|
}
|
|
|
|
static astro_status_t FindSeasonChange(double targetLon, int year, int month, int day, astro_time_t *time)
|
|
{
|
|
astro_time_t startTime = Astronomy_MakeTime(year, month, day, 0, 0, 0.0);
|
|
astro_search_result_t result = Astronomy_SearchSunLongitude(targetLon, startTime, 4.0);
|
|
*time = result.time;
|
|
return result.status;
|
|
}
|
|
|
|
/**
|
|
* @brief Finds both equinoxes and both solstices for a given calendar year.
|
|
*
|
|
* The changes of seasons are defined by solstices and equinoxes.
|
|
* Given a calendar year number, this function calculates the
|
|
* March and September equinoxes and the June and December solstices.
|
|
*
|
|
* The equinoxes are the moments twice each year when the plane of the
|
|
* Earth's equator passes through the center of the Sun. In other words,
|
|
* the Sun's declination is zero at both equinoxes.
|
|
* The March equinox defines the beginning of spring in the northern hemisphere
|
|
* and the beginning of autumn in the southern hemisphere.
|
|
* The September equinox defines the beginning of autumn in the northern hemisphere
|
|
* and the beginning of spring in the southern hemisphere.
|
|
*
|
|
* The solstices are the moments twice each year when one of the Earth's poles
|
|
* is most tilted toward the Sun. More precisely, the Sun's declination reaches
|
|
* its minimum value at the December solstice, which defines the beginning of
|
|
* winter in the northern hemisphere and the beginning of summer in the southern
|
|
* hemisphere. The Sun's declination reaches its maximum value at the June solstice,
|
|
* which defines the beginning of summer in the northern hemisphere and the beginning
|
|
* of winter in the southern hemisphere.
|
|
*
|
|
* @param year
|
|
* The calendar year number for which to calculate equinoxes and solstices.
|
|
* The value may be any integer, but only the years 1800 through 2100 have been
|
|
* validated for accuracy: unit testing against data from the
|
|
* United States Naval Observatory confirms that all equinoxes and solstices
|
|
* for that range of years are within 2 minutes of the correct time.
|
|
*
|
|
* @return
|
|
* The times of the four seasonal changes in the given calendar year.
|
|
* This function should always succeed. However, to be safe, callers
|
|
* should check the `status` field of the returned structure to make sure
|
|
* it contains `ASTRO_SUCCESS`. Any failures indicate a bug in the algorithm
|
|
* and should be [reported as an issue](https://github.com/cosinekitty/astronomy/issues).
|
|
*/
|
|
astro_seasons_t Astronomy_Seasons(int year)
|
|
{
|
|
astro_seasons_t seasons;
|
|
astro_status_t status;
|
|
|
|
seasons.status = ASTRO_SUCCESS;
|
|
|
|
status = FindSeasonChange( 0, year, 3, 19, &seasons.mar_equinox);
|
|
if (status != ASTRO_SUCCESS) seasons.status = status;
|
|
|
|
status = FindSeasonChange( 90, year, 6, 19, &seasons.jun_solstice);
|
|
if (status != ASTRO_SUCCESS) seasons.status = status;
|
|
|
|
status = FindSeasonChange(180, year, 9, 21, &seasons.sep_equinox);
|
|
if (status != ASTRO_SUCCESS) seasons.status = status;
|
|
|
|
status = FindSeasonChange(270, year, 12, 20, &seasons.dec_solstice);
|
|
if (status != ASTRO_SUCCESS) seasons.status = status;
|
|
|
|
return seasons;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the angle between the given body and the Sun, as seen from the Earth.
|
|
*
|
|
* This function calculates the angular separation between the given body and the Sun,
|
|
* as seen from the center of the Earth. This angle is helpful for determining how
|
|
* easy it is to see the body away from the glare of the Sun.
|
|
*
|
|
* @param body
|
|
* The celestial body whose angle from the Sun is to be measured.
|
|
* Not allowed to be `BODY_EARTH`.
|
|
*
|
|
* @param time
|
|
* The time at which the observation is made.
|
|
*
|
|
* @return
|
|
* If successful, the returned structure contains `ASTRO_SUCCESS` in the `status` field
|
|
* and `angle` holds the angle in degrees between the Sun and the specified body as
|
|
* seen from the center of the Earth.
|
|
* If an error occurs, the `status` field contains a value other than `ASTRO_SUCCESS`
|
|
* that indicates the error condition.
|
|
*/
|
|
astro_angle_result_t Astronomy_AngleFromSun(astro_body_t body, astro_time_t time)
|
|
{
|
|
astro_vector_t sv, bv;
|
|
|
|
if (body == BODY_EARTH)
|
|
return AngleError(ASTRO_EARTH_NOT_ALLOWED);
|
|
|
|
sv = Astronomy_GeoVector(BODY_SUN, time, ABERRATION);
|
|
if (sv.status != ASTRO_SUCCESS)
|
|
return AngleError(sv.status);
|
|
|
|
bv = Astronomy_GeoVector(body, time, ABERRATION);
|
|
if (bv.status != ASTRO_SUCCESS)
|
|
return AngleError(bv.status);
|
|
|
|
return AngleBetween(sv, bv);
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Determines visibility of a celestial body relative to the Sun, as seen from the Earth.
|
|
*
|
|
* This function returns an #astro_elongation_t structure, which provides the following
|
|
* information about the given celestial body at the given time:
|
|
*
|
|
* - `visibility` is an enumerated type that specifies whether the body is more easily seen
|
|
* in the morning before sunrise, or in the evening after sunset.
|
|
*
|
|
* - `elongation` is the angle in degrees between two vectors: one from the center of the Earth to the
|
|
* center of the Sun, the other from the center of the Earth to the center of the specified body.
|
|
* This angle indicates how far away the body is from the glare of the Sun.
|
|
* The elongation angle is always in the range [0, 180].
|
|
*
|
|
* - `ecliptic_separation` is the absolute value of the difference between the body's ecliptic longitude
|
|
* and the Sun's ecliptic longitude, both as seen from the center of the Earth. This angle measures
|
|
* around the plane of the Earth's orbit, and ignores how far above or below that plane the body is.
|
|
* The ecliptic separation is measured in degrees and is always in the range [0, 180].
|
|
*
|
|
* @param body
|
|
* The celestial body whose visibility is to be calculated.
|
|
*
|
|
* @param time
|
|
* The date and time of the observation.
|
|
*
|
|
* @return
|
|
* If successful, the `status` field in the returned structure contains `ASTRO_SUCCESS`
|
|
* and all the other fields in the structure are valid. On failure, `status` contains
|
|
* some other value as an error code and the other fields contain invalid values.
|
|
*/
|
|
astro_elongation_t Astronomy_Elongation(astro_body_t body, astro_time_t time)
|
|
{
|
|
astro_elongation_t result;
|
|
astro_angle_result_t angres;
|
|
|
|
angres = Astronomy_LongitudeFromSun(body, time);
|
|
if (angres.status != ASTRO_SUCCESS)
|
|
return ElongError(angres.status);
|
|
|
|
if (angres.angle > 180.0)
|
|
{
|
|
result.visibility = VISIBLE_MORNING;
|
|
result.ecliptic_separation = 360.0 - angres.angle;
|
|
}
|
|
else
|
|
{
|
|
result.visibility = VISIBLE_EVENING;
|
|
result.ecliptic_separation = angres.angle;
|
|
}
|
|
|
|
angres = Astronomy_AngleFromSun(body, time);
|
|
if (angres.status != ASTRO_SUCCESS)
|
|
return ElongError(angres.status);
|
|
|
|
result.elongation = angres.angle;
|
|
result.time = time;
|
|
result.status = ASTRO_SUCCESS;
|
|
|
|
return result;
|
|
}
|
|
|
|
static astro_func_result_t neg_elong_slope(void *context, astro_time_t time)
|
|
{
|
|
static const double dt = 0.1;
|
|
astro_angle_result_t e1, e2;
|
|
astro_func_result_t result;
|
|
astro_body_t body = *((astro_body_t *)context);
|
|
astro_time_t t1 = Astronomy_AddDays(time, -dt/2.0);
|
|
astro_time_t t2 = Astronomy_AddDays(time, +dt/2.0);
|
|
|
|
e1 = Astronomy_AngleFromSun(body, t1);
|
|
if (e1.status != ASTRO_SUCCESS)
|
|
return FuncError(e1.status);
|
|
|
|
e2 = Astronomy_AngleFromSun(body, t2);
|
|
if (e2.status)
|
|
return FuncError(e2.status);
|
|
|
|
result.value = (e1.angle - e2.angle)/dt;
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Finds a date and time when Mercury or Venus reaches its maximum angle from the Sun as seen from the Earth.
|
|
*
|
|
* Mercury and Venus are are often difficult to observe because they are closer to the Sun than the Earth is.
|
|
* Mercury especially is almost always impossible to see because it gets lost in the Sun's glare.
|
|
* The best opportunities for spotting Mercury, and the best opportunities for viewing Venus through
|
|
* a telescope without atmospheric interference, are when these planets reach maximum elongation.
|
|
* These are events where the planets reach the maximum angle from the Sun as seen from the Earth.
|
|
*
|
|
* This function solves for those times, reporting the next maximum elongation event's date and time,
|
|
* the elongation value itself, the relative longitude with the Sun, and whether the planet is best
|
|
* observed in the morning or evening. See #Astronomy_Elongation for more details about the returned structure.
|
|
*
|
|
* @param body
|
|
* Either `BODY_MERCURY` or `BODY_VENUS`. Any other value will fail with the error `ASTRO_INVALID_BODY`.
|
|
* To find the best viewing opportunites for planets farther from the Sun than the Earth is (Mars through Pluto)
|
|
* use #Astronomy_SearchRelativeLongitude to find the next opposition event.
|
|
*
|
|
* @param startTime
|
|
* The date and time at which to begin the search. The maximum elongation event found will always
|
|
* be the first one that occurs after this date and time.
|
|
*
|
|
* @return
|
|
* If successful, the `status` field of the returned structure will be `ASTRO_SUCCESS`
|
|
* and the other structure fields will be valid. Otherwise, `status` will contain
|
|
* some other value indicating an error.
|
|
*/
|
|
astro_elongation_t Astronomy_SearchMaxElongation(astro_body_t body, astro_time_t startTime)
|
|
{
|
|
double s1, s2;
|
|
int iter;
|
|
astro_angle_result_t plon, elon;
|
|
astro_time_t t_start;
|
|
double rlon, rlon_lo, rlon_hi, adjust_days;
|
|
astro_func_result_t syn;
|
|
astro_search_result_t search1, search2, searchx;
|
|
astro_time_t t1, t2;
|
|
astro_func_result_t m1, m2;
|
|
|
|
/* Determine the range of relative longitudes within which maximum elongation can occur for this planet. */
|
|
switch (body)
|
|
{
|
|
case BODY_MERCURY:
|
|
s1 = 50.0;
|
|
s2 = 85.0;
|
|
break;
|
|
|
|
case BODY_VENUS:
|
|
s1 = 40.0;
|
|
s2 = 50.0;
|
|
break;
|
|
|
|
default:
|
|
/* SearchMaxElongation works for Mercury and Venus only. */
|
|
return ElongError(ASTRO_INVALID_BODY);
|
|
}
|
|
|
|
syn = SynodicPeriod(body);
|
|
if (syn.status != ASTRO_SUCCESS)
|
|
return ElongError(syn.status);
|
|
|
|
iter = 0;
|
|
while (++iter <= 2)
|
|
{
|
|
plon = Astronomy_EclipticLongitude(body, startTime);
|
|
if (plon.status != ASTRO_SUCCESS)
|
|
return ElongError(plon.status);
|
|
|
|
elon = Astronomy_EclipticLongitude(BODY_EARTH, startTime);
|
|
if (elon.status != ASTRO_SUCCESS)
|
|
return ElongError(elon.status);
|
|
|
|
rlon = LongitudeOffset(plon.angle - elon.angle); /* clamp to (-180, +180] */
|
|
|
|
/* The slope function is not well-behaved when rlon is near 0 degrees or 180 degrees */
|
|
/* because there is a cusp there that causes a discontinuity in the derivative. */
|
|
/* So we need to guard against searching near such times. */
|
|
if (rlon >= -s1 && rlon < +s1)
|
|
{
|
|
/* Seek to the window [+s1, +s2]. */
|
|
adjust_days = 0.0;
|
|
/* Search forward for the time t1 when rel lon = +s1. */
|
|
rlon_lo = +s1;
|
|
/* Search forward for the time t2 when rel lon = +s2. */
|
|
rlon_hi = +s2;
|
|
}
|
|
else if (rlon > +s2 || rlon < -s2)
|
|
{
|
|
/* Seek to the next search window at [-s2, -s1]. */
|
|
adjust_days = 0.0;
|
|
/* Search forward for the time t1 when rel lon = -s2. */
|
|
rlon_lo = -s2;
|
|
/* Search forward for the time t2 when rel lon = -s1. */
|
|
rlon_hi = -s1;
|
|
}
|
|
else if (rlon >= 0.0)
|
|
{
|
|
/* rlon must be in the middle of the window [+s1, +s2]. */
|
|
/* Search BACKWARD for the time t1 when rel lon = +s1. */
|
|
adjust_days = -syn.value / 4.0;
|
|
rlon_lo = +s1;
|
|
rlon_hi = +s2;
|
|
/* Search forward from t1 to find t2 such that rel lon = +s2. */
|
|
}
|
|
else
|
|
{
|
|
/* rlon must be in the middle of the window [-s2, -s1]. */
|
|
/* Search BACKWARD for the time t1 when rel lon = -s2. */
|
|
adjust_days = -syn.value / 4.0;
|
|
rlon_lo = -s2;
|
|
/* Search forward from t1 to find t2 such that rel lon = -s1. */
|
|
rlon_hi = -s1;
|
|
}
|
|
|
|
t_start = Astronomy_AddDays(startTime, adjust_days);
|
|
|
|
search1 = Astronomy_SearchRelativeLongitude(body, rlon_lo, t_start);
|
|
if (search1.status != ASTRO_SUCCESS)
|
|
return ElongError(search1.status);
|
|
t1 = search1.time;
|
|
|
|
search2 = Astronomy_SearchRelativeLongitude(body, rlon_hi, t1);
|
|
if (search2.status != ASTRO_SUCCESS)
|
|
return ElongError(search2.status);
|
|
t2 = search2.time;
|
|
|
|
/* Now we have a time range [t1,t2] that brackets a maximum elongation event. */
|
|
/* Confirm the bracketing. */
|
|
m1 = neg_elong_slope(&body, t1);
|
|
if (m1.status != ASTRO_SUCCESS)
|
|
return ElongError(m1.status);
|
|
|
|
if (m1.value >= 0)
|
|
return ElongError(ASTRO_INTERNAL_ERROR); /* there is a bug in the bracketing algorithm! */
|
|
|
|
m2 = neg_elong_slope(&body, t2);
|
|
if (m2.status != ASTRO_SUCCESS)
|
|
return ElongError(m2.status);
|
|
|
|
if (m2.value <= 0)
|
|
return ElongError(ASTRO_INTERNAL_ERROR); /* there is a bug in the bracketing algorithm! */
|
|
|
|
/* Use the generic search algorithm to home in on where the slope crosses from negative to positive. */
|
|
searchx = Astronomy_Search(neg_elong_slope, &body, t1, t2, 10.0);
|
|
if (searchx.status != ASTRO_SUCCESS)
|
|
return ElongError(searchx.status);
|
|
|
|
if (searchx.time.tt >= startTime.tt)
|
|
return Astronomy_Elongation(body, searchx.time);
|
|
|
|
/* This event is in the past (earlier than startTime). */
|
|
/* We need to search forward from t2 to find the next possible window. */
|
|
/* We never need to search more than twice. */
|
|
startTime = Astronomy_AddDays(t2, 1.0);
|
|
}
|
|
|
|
return ElongError(ASTRO_SEARCH_FAILURE);
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Returns a body's ecliptic longitude with respect to the Sun, as seen from the Earth.
|
|
*
|
|
* This function can be used to determine where a planet appears around the ecliptic plane
|
|
* (the plane of the Earth's orbit around the Sun) as seen from the Earth,
|
|
* relative to the Sun's apparent position.
|
|
*
|
|
* The angle starts at 0 when the body and the Sun are at the same ecliptic longitude
|
|
* as seen from the Earth. The angle increases in the prograde direction
|
|
* (the direction that the planets orbit the Sun and the Moon orbits the Earth).
|
|
*
|
|
* When the angle is 180 degrees, it means the Sun and the body appear on opposite sides
|
|
* of the sky for an Earthly observer. When `body` is a planet whose orbit around the
|
|
* Sun is farther than the Earth's, 180 degrees indicates opposition. For the Moon,
|
|
* it indicates a full moon.
|
|
*
|
|
* The angle keeps increasing up to 360 degrees as the body's apparent prograde
|
|
* motion continues relative to the Sun. When the angle reaches 360 degrees, it starts
|
|
* over at 0 degrees.
|
|
*
|
|
* Values between 0 and 180 degrees indicate that the body is visible in the evening sky
|
|
* after sunset. Values between 180 degrees and 360 degrees indicate that the body
|
|
* is visible in the morning sky before sunrise.
|
|
*
|
|
* @param body
|
|
* The celestial body for which to find longitude from the Sun.
|
|
*
|
|
* @param time
|
|
* The date and time of the observation.
|
|
*
|
|
* @return
|
|
* On success, the `status` field in the returned structure holds `ASTRO_SUCCESS` and
|
|
* the `angle` field holds a value in the range [0, 360).
|
|
* On failure, the `status` field contains some other value indicating an error condition.
|
|
*/
|
|
astro_angle_result_t Astronomy_LongitudeFromSun(astro_body_t body, astro_time_t time)
|
|
{
|
|
astro_vector_t sv, bv;
|
|
astro_ecliptic_t se, be;
|
|
astro_angle_result_t result;
|
|
|
|
if (body == BODY_EARTH)
|
|
return AngleError(ASTRO_EARTH_NOT_ALLOWED);
|
|
|
|
sv = Astronomy_GeoVector(BODY_SUN, time, NO_ABERRATION);
|
|
se = Astronomy_Ecliptic(sv); /* checks for errors in sv */
|
|
if (se.status != ASTRO_SUCCESS)
|
|
return AngleError(se.status);
|
|
|
|
bv = Astronomy_GeoVector(body, time, NO_ABERRATION);
|
|
be = Astronomy_Ecliptic(bv); /* checks for errors in bv */
|
|
if (be.status != ASTRO_SUCCESS)
|
|
return AngleError(be.status);
|
|
|
|
result.status = ASTRO_SUCCESS;
|
|
result.angle = NormalizeLongitude(be.elon - se.elon);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Returns the Moon's phase as an angle from 0 to 360 degrees.
|
|
*
|
|
* This function determines the phase of the Moon using its apparent
|
|
* ecliptic longitude relative to the Sun, as seen from the center of the Earth.
|
|
* Certain values of the angle have conventional definitions:
|
|
*
|
|
* - 0 = new moon
|
|
* - 90 = first quarter
|
|
* - 180 = full moon
|
|
* - 270 = third quarter
|
|
*
|
|
* @param time
|
|
* The date and time of the observation.
|
|
*
|
|
* @return
|
|
* On success, the function returns the angle as described in the function remarks
|
|
* in the `angle` field and `ASTRO_SUCCESS` in the `status` field.
|
|
* The function should always succeed, but it is a good idea for callers to check
|
|
* the `status` field in the returned structure.
|
|
* Any other value in `status` indicates a failure that should be
|
|
* [reported as an issue](https://github.com/cosinekitty/astronomy/issues).
|
|
*/
|
|
astro_angle_result_t Astronomy_MoonPhase(astro_time_t time)
|
|
{
|
|
return Astronomy_LongitudeFromSun(BODY_MOON, time);
|
|
}
|
|
|
|
static astro_func_result_t moon_offset(void *context, astro_time_t time)
|
|
{
|
|
astro_func_result_t result;
|
|
double targetLon = *((double *)context);
|
|
astro_angle_result_t angres = Astronomy_MoonPhase(time);
|
|
if (angres.status != ASTRO_SUCCESS)
|
|
return FuncError(angres.status);
|
|
result.value = LongitudeOffset(angres.angle - targetLon);
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Searches for the time that the Moon reaches a specified phase.
|
|
*
|
|
* Lunar phases are conventionally defined in terms of the Moon's geocentric ecliptic
|
|
* longitude with respect to the Sun's geocentric ecliptic longitude.
|
|
* When the Moon and the Sun have the same longitude, that is defined as a new moon.
|
|
* When their longitudes are 180 degrees apart, that is defined as a full moon.
|
|
*
|
|
* This function searches for any value of the lunar phase expressed as an
|
|
* angle in degrees in the range [0, 360).
|
|
*
|
|
* If you want to iterate through lunar quarters (new moon, first quarter, full moon, third quarter)
|
|
* it is much easier to call the functions #Astronomy_SearchMoonQuarter and #Astronomy_NextMoonQuarter.
|
|
* This function is useful for finding general phase angles outside those four quarters.
|
|
*
|
|
* @param targetLon
|
|
* The difference in geocentric longitude between the Sun and Moon
|
|
* that specifies the lunar phase being sought. This can be any value
|
|
* in the range [0, 360). Certain values have conventional names:
|
|
* 0 = new moon, 90 = first quarter, 180 = full moon, 270 = third quarter.
|
|
*
|
|
* @param startTime
|
|
* The beginning of the time window in which to search for the Moon reaching the specified phase.
|
|
*
|
|
* @param limitDays
|
|
* The number of days after `startTime` that limits the time window for the search.
|
|
*
|
|
* @return
|
|
* On success, the `status` field in the returned structure holds `ASTRO_SUCCESS` and
|
|
* the `time` field holds the date and time when the Moon reaches the target longitude.
|
|
* On failure, `status` holds some other value as an error code.
|
|
* One possible error code is `ASTRO_NO_MOON_QUARTER` if `startTime` and `limitDays`
|
|
* do not enclose the desired event. See remarks in #Astronomy_Search for other possible
|
|
* error codes.
|
|
*/
|
|
astro_search_result_t Astronomy_SearchMoonPhase(double targetLon, astro_time_t startTime, double limitDays)
|
|
{
|
|
/*
|
|
To avoid discontinuities in the moon_offset function causing problems,
|
|
we need to approximate when that function will next return 0.
|
|
We probe it with the start time and take advantage of the fact
|
|
that every lunar phase repeats roughly every 29.5 days.
|
|
There is a surprising uncertainty in the quarter timing,
|
|
due to the eccentricity of the moon's orbit.
|
|
I have seen up to 0.826 days away from the simple prediction.
|
|
To be safe, we take the predicted time of the event and search
|
|
+/-0.9 days around it (a 1.8-day wide window).
|
|
Return ASTRO_NO_MOON_QUARTER if the final result goes beyond limitDays after startTime.
|
|
*/
|
|
const double uncertainty = 0.9;
|
|
astro_func_result_t funcres;
|
|
double ya, est_dt, dt1, dt2;
|
|
astro_time_t t1, t2;
|
|
|
|
funcres = moon_offset(&targetLon, startTime);
|
|
if (funcres.status != ASTRO_SUCCESS)
|
|
return SearchError(funcres.status);
|
|
|
|
ya = funcres.value;
|
|
if (ya > 0.0) ya -= 360.0; /* force searching forward in time, not backward */
|
|
est_dt = -(MEAN_SYNODIC_MONTH * ya) / 360.0;
|
|
dt1 = est_dt - uncertainty;
|
|
if (dt1 > limitDays)
|
|
return SearchError(ASTRO_NO_MOON_QUARTER); /* not possible for moon phase to occur within specified window (too short) */
|
|
dt2 = est_dt + uncertainty;
|
|
if (limitDays < dt2)
|
|
dt2 = limitDays;
|
|
t1 = Astronomy_AddDays(startTime, dt1);
|
|
t2 = Astronomy_AddDays(startTime, dt2);
|
|
return Astronomy_Search(moon_offset, &targetLon, t1, t2, 1.0);
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Finds the first lunar quarter after the specified date and time.
|
|
*
|
|
* A lunar quarter is one of the following four lunar phase events:
|
|
* new moon, first quarter, full moon, third quarter.
|
|
* This function finds the lunar quarter that happens soonest
|
|
* after the specified date and time.
|
|
*
|
|
* To continue iterating through consecutive lunar quarters, call this function once,
|
|
* followed by calls to #Astronomy_NextMoonQuarter as many times as desired.
|
|
*
|
|
* @param startTime
|
|
* The date and time at which to start the search.
|
|
*
|
|
* @return
|
|
* This function should always succeed, indicated by the `status` field
|
|
* in the returned structure holding `ASTRO_SUCCESS`. Any other value indicates
|
|
* an internal error, which should be [reported as an issue](https://github.com/cosinekitty/astronomy/issues).
|
|
* To be safe, calling code should always check the `status` field for errors.
|
|
*/
|
|
astro_moon_quarter_t Astronomy_SearchMoonQuarter(astro_time_t startTime)
|
|
{
|
|
astro_moon_quarter_t mq;
|
|
astro_angle_result_t angres;
|
|
astro_search_result_t srchres;
|
|
|
|
/* Determine what the next quarter phase will be. */
|
|
angres = Astronomy_MoonPhase(startTime);
|
|
if (angres.status != ASTRO_SUCCESS)
|
|
return MoonQuarterError(angres.status);
|
|
|
|
mq.quarter = (1 + (int)floor(angres.angle / 90.0)) % 4;
|
|
srchres = Astronomy_SearchMoonPhase(90.0 * mq.quarter, startTime, 10.0);
|
|
if (srchres.status != ASTRO_SUCCESS)
|
|
return MoonQuarterError(srchres.status);
|
|
|
|
mq.status = ASTRO_SUCCESS;
|
|
mq.time = srchres.time;
|
|
return mq;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Continues searching for lunar quarters from a previous search.
|
|
*
|
|
* After calling #Astronomy_SearchMoonQuarter, this function can be called
|
|
* one or more times to continue finding consecutive lunar quarters.
|
|
* This function finds the next consecutive moon quarter event after the one passed in as the parameter `mq`.
|
|
*
|
|
* @param mq
|
|
* A value returned by a prior call to #Astronomy_SearchMoonQuarter or #Astronomy_NextMoonQuarter.
|
|
*
|
|
* @return
|
|
* If `mq` is valid, this function should always succeed, indicated by the `status` field
|
|
* in the returned structure holding `ASTRO_SUCCESS`. Any other value indicates
|
|
* an internal error, which (after confirming that `mq` is valid) should be
|
|
* [reported as an issue](https://github.com/cosinekitty/astronomy/issues).
|
|
* To be safe, calling code should always check the `status` field for errors.
|
|
*/
|
|
astro_moon_quarter_t Astronomy_NextMoonQuarter(astro_moon_quarter_t mq)
|
|
{
|
|
astro_time_t time;
|
|
astro_moon_quarter_t next_mq;
|
|
|
|
if (mq.status != ASTRO_SUCCESS)
|
|
return MoonQuarterError(ASTRO_INVALID_PARAMETER);
|
|
|
|
/* Skip 6 days past the previous found moon quarter to find the next one. */
|
|
/* This is less than the minimum possible increment. */
|
|
/* So far I have seen the interval well contained by the range (6.5, 8.3) days. */
|
|
|
|
time = Astronomy_AddDays(mq.time, 6.0);
|
|
next_mq = Astronomy_SearchMoonQuarter(time);
|
|
if (next_mq.status == ASTRO_SUCCESS)
|
|
{
|
|
/* Verify that we found the expected moon quarter. */
|
|
if (next_mq.quarter != (1 + mq.quarter) % 4)
|
|
return MoonQuarterError(ASTRO_WRONG_MOON_QUARTER); /* internal error! we found the wrong moon quarter */
|
|
}
|
|
return next_mq;
|
|
}
|
|
|
|
static astro_func_result_t rlon_offset(astro_body_t body, astro_time_t time, int direction, double targetRelLon)
|
|
{
|
|
astro_func_result_t result;
|
|
astro_angle_result_t plon, elon;
|
|
double diff;
|
|
|
|
plon = Astronomy_EclipticLongitude(body, time);
|
|
if (plon.status != ASTRO_SUCCESS)
|
|
return FuncError(plon.status);
|
|
|
|
elon = Astronomy_EclipticLongitude(BODY_EARTH, time);
|
|
if (elon.status != ASTRO_SUCCESS)
|
|
return FuncError(elon.status);
|
|
|
|
diff = direction * (elon.angle - plon.angle);
|
|
result.value = LongitudeOffset(diff - targetRelLon);
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Searches for the time when the Earth and another planet are separated by a specified angle
|
|
* in ecliptic longitude, as seen from the Sun.
|
|
*
|
|
* A relative longitude is the angle between two bodies measured in the plane of the Earth's orbit
|
|
* (the ecliptic plane). The distance of the bodies above or below the ecliptic plane is ignored.
|
|
* If you imagine the shadow of the body cast onto the ecliptic plane, and the angle measured around
|
|
* that plane from one body to the other in the direction the planets orbit the Sun, you will get an
|
|
* angle somewhere between 0 and 360 degrees. This is the relative longitude.
|
|
*
|
|
* Given a planet other than the Earth in `body` and a time to start the search in `startTime`,
|
|
* this function searches for the next time that the relative longitude measured from the planet
|
|
* to the Earth is `targetRelLon`.
|
|
*
|
|
* Certain astronomical events are defined in terms of relative longitude between the Earth and another planet:
|
|
*
|
|
* - When the relative longitude is 0 degrees, it means both planets are in the same direction from the Sun.
|
|
* For planets that orbit closer to the Sun (Mercury and Venus), this is known as *inferior conjunction*,
|
|
* a time when the other planet becomes very difficult to see because of being lost in the Sun's glare.
|
|
* (The only exception is in the rare event of a transit, when we see the silhouette of the planet passing
|
|
* between the Earth and the Sun.)
|
|
*
|
|
* - When the relative longitude is 0 degrees and the other planet orbits farther from the Sun,
|
|
* this is known as *opposition*. Opposition is when the planet is closest to the Earth, and
|
|
* also when it is visible for most of the night, so it is considered the best time to observe the planet.
|
|
*
|
|
* - When the relative longitude is 180 degrees, it means the other planet is on the opposite side of the Sun
|
|
* from the Earth. This is called *superior conjunction*. Like inferior conjunction, the planet is
|
|
* very difficult to see from the Earth. Superior conjunction is possible for any planet other than the Earth.
|
|
*
|
|
* @param body
|
|
* A planet other than the Earth. If `body` is not a planet other than the Earth, an error occurs.
|
|
*
|
|
* @param targetRelLon
|
|
* The desired relative longitude, expressed in degrees. Must be in the range [0, 360).
|
|
*
|
|
* @param startTime
|
|
* The date and time at which to begin the search.
|
|
*
|
|
* @return
|
|
* If successful, the `status` field in the returned structure will contain `ASTRO_SUCCESS`
|
|
* and `time` will hold the date and time of the relative longitude event.
|
|
* Otherwise `status` will hold some other value that indicates an error condition.
|
|
*/
|
|
astro_search_result_t Astronomy_SearchRelativeLongitude(astro_body_t body, double targetRelLon, astro_time_t startTime)
|
|
{
|
|
astro_search_result_t result;
|
|
astro_func_result_t syn;
|
|
astro_func_result_t error_angle;
|
|
double prev_angle;
|
|
astro_time_t time;
|
|
int iter, direction;
|
|
|
|
if (body == BODY_EARTH)
|
|
return SearchError(ASTRO_EARTH_NOT_ALLOWED);
|
|
|
|
if (body == BODY_MOON || body == BODY_SUN)
|
|
return SearchError(ASTRO_INVALID_BODY);
|
|
|
|
syn = SynodicPeriod(body);
|
|
if (syn.status != ASTRO_SUCCESS)
|
|
return SearchError(syn.status);
|
|
|
|
direction = IsSuperiorPlanet(body) ? +1 : -1;
|
|
|
|
/* Iterate until we converge on the desired event. */
|
|
/* Calculate the error angle, which will be a negative number of degrees, */
|
|
/* meaning we are "behind" the target relative longitude. */
|
|
|
|
error_angle = rlon_offset(body, startTime, direction, targetRelLon);
|
|
if (error_angle.status != ASTRO_SUCCESS)
|
|
return SearchError(error_angle.status);
|
|
|
|
if (error_angle.value > 0)
|
|
error_angle.value -= 360; /* force searching forward in time */
|
|
|
|
time = startTime;
|
|
for (iter = 0; iter < 100; ++iter)
|
|
{
|
|
/* Estimate how many days in the future (positive) or past (negative) */
|
|
/* we have to go to get closer to the target relative longitude. */
|
|
double day_adjust = (-error_angle.value/360.0) * syn.value;
|
|
time = Astronomy_AddDays(time, day_adjust);
|
|
if (fabs(day_adjust) * SECONDS_PER_DAY < 1.0)
|
|
{
|
|
result.time = time;
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
prev_angle = error_angle.value;
|
|
error_angle = rlon_offset(body, time, direction, targetRelLon);
|
|
if (error_angle.status != ASTRO_SUCCESS)
|
|
return SearchError(error_angle.status);
|
|
|
|
if (fabs(prev_angle) < 30.0 && (prev_angle != error_angle.value))
|
|
{
|
|
/* Improve convergence for Mercury/Mars (eccentric orbits) */
|
|
/* by adjusting the synodic period to more closely match the */
|
|
/* variable speed of both planets in this part of their respective orbits. */
|
|
double ratio = prev_angle / (prev_angle - error_angle.value);
|
|
if (ratio > 0.5 && ratio < 2.0)
|
|
syn.value *= ratio;
|
|
}
|
|
}
|
|
|
|
return SearchError(ASTRO_NO_CONVERGE);
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Searches for the time when a celestial body reaches a specified hour angle as seen by an observer on the Earth.
|
|
*
|
|
* The *hour angle* of a celestial body indicates its position in the sky with respect
|
|
* to the Earth's rotation. The hour angle depends on the location of the observer on the Earth.
|
|
* The hour angle is 0 when the body reaches its highest angle above the horizon in a given day.
|
|
* The hour angle increases by 1 unit for every sidereal hour that passes after that point, up
|
|
* to 24 sidereal hours when it reaches the highest point again. So the hour angle indicates
|
|
* the number of hours that have passed since the most recent time that the body has culminated,
|
|
* or reached its highest point.
|
|
*
|
|
* This function searches for the next time a celestial body reaches the given hour angle
|
|
* after the date and time specified by `startTime`.
|
|
* To find when a body culminates, pass 0 for `hourAngle`.
|
|
* To find when a body reaches its lowest point in the sky, pass 12 for `hourAngle`.
|
|
*
|
|
* Note that, especially close to the Earth's poles, a body as seen on a given day
|
|
* may always be above the horizon or always below the horizon, so the caller cannot
|
|
* assume that a culminating object is visible nor that an object is below the horizon
|
|
* at its minimum altitude.
|
|
*
|
|
* On success, the function reports the date and time, along with the horizontal coordinates
|
|
* of the body at that time, as seen by the given observer.
|
|
*
|
|
* @param body
|
|
* The celestial body, which can the Sun, the Moon, or any planet other than the Earth.
|
|
*
|
|
* @param observer
|
|
* Indicates a location on or near the surface of the Earth where the observer is located.
|
|
* Call #Astronomy_MakeObserver to create an observer structure.
|
|
*
|
|
* @param hourAngle
|
|
* An hour angle value in the range [0, 24) indicating the number of sidereal hours after the
|
|
* body's most recent culmination.
|
|
*
|
|
* @param startTime
|
|
* The date and time at which to start the search.
|
|
*
|
|
* @return
|
|
* If successful, the `status` field in the returned structure holds `ASTRO_SUCCESS`
|
|
* and the other structure fields are valid. Otherwise, `status` holds some other value
|
|
* that indicates an error condition.
|
|
*/
|
|
astro_hour_angle_t Astronomy_SearchHourAngle(
|
|
astro_body_t body,
|
|
astro_observer_t observer,
|
|
double hourAngle,
|
|
astro_time_t startTime)
|
|
{
|
|
int iter = 0;
|
|
astro_time_t time;
|
|
astro_equatorial_t ofdate;
|
|
astro_hour_angle_t result;
|
|
double delta_sidereal_hours, delta_days, gast;
|
|
|
|
if (body < MIN_BODY || body > MAX_BODY)
|
|
return HourAngleError(ASTRO_INVALID_BODY);
|
|
|
|
if (body == BODY_EARTH)
|
|
return HourAngleError(ASTRO_EARTH_NOT_ALLOWED);
|
|
|
|
if (hourAngle < 0.0 || hourAngle >= 24.0)
|
|
return HourAngleError(ASTRO_INVALID_PARAMETER);
|
|
|
|
time = startTime;
|
|
for(;;)
|
|
{
|
|
++iter;
|
|
|
|
/* Calculate Greenwich Apparent Sidereal Time (GAST) at the given time. */
|
|
gast = sidereal_time(&time);
|
|
|
|
/* Obtain equatorial coordinates of date for the body. */
|
|
ofdate = Astronomy_Equator(body, &time, observer, EQUATOR_OF_DATE, ABERRATION);
|
|
if (ofdate.status != ASTRO_SUCCESS)
|
|
return HourAngleError(ofdate.status);
|
|
|
|
/* Calculate the adjustment needed in sidereal time */
|
|
/* to bring the hour angle to the desired value. */
|
|
|
|
delta_sidereal_hours = fmod((hourAngle + ofdate.ra - observer.longitude/15) - gast, 24.0);
|
|
if (iter == 1)
|
|
{
|
|
/* On the first iteration, always search forward in time. */
|
|
if (delta_sidereal_hours < 0)
|
|
delta_sidereal_hours += 24;
|
|
}
|
|
else
|
|
{
|
|
/* On subsequent iterations, we make the smallest possible adjustment, */
|
|
/* either forward or backward in time. */
|
|
if (delta_sidereal_hours < -12.0)
|
|
delta_sidereal_hours += 24.0;
|
|
else if (delta_sidereal_hours > +12.0)
|
|
delta_sidereal_hours -= 24.0;
|
|
}
|
|
|
|
/* If the error is tolerable (less than 0.1 seconds), the search has succeeded. */
|
|
if (fabs(delta_sidereal_hours) * 3600.0 < 0.1)
|
|
{
|
|
result.hor = Astronomy_Horizon(&time, observer, ofdate.ra, ofdate.dec, REFRACTION_NORMAL);
|
|
result.time = time;
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
/* We need to loop another time to get more accuracy. */
|
|
/* Update the terrestrial time (in solar days) adjusting by sidereal time (sidereal hours). */
|
|
delta_days = (delta_sidereal_hours / 24.0) * SOLAR_DAYS_PER_SIDEREAL_DAY;
|
|
time = Astronomy_AddDays(time, delta_days);
|
|
}
|
|
}
|
|
|
|
/** @cond DOXYGEN_SKIP */
|
|
typedef struct
|
|
{
|
|
astro_body_t body;
|
|
int direction;
|
|
astro_observer_t observer;
|
|
double body_radius_au;
|
|
}
|
|
context_peak_altitude_t;
|
|
/** @endcond */
|
|
|
|
static astro_func_result_t peak_altitude(void *context, astro_time_t time)
|
|
{
|
|
astro_func_result_t result;
|
|
astro_equatorial_t ofdate;
|
|
astro_horizon_t hor;
|
|
const context_peak_altitude_t *p = context;
|
|
|
|
/*
|
|
Return the angular altitude above or below the horizon
|
|
of the highest part (the peak) of the given object.
|
|
This is defined as the apparent altitude of the center of the body plus
|
|
the body's angular radius.
|
|
The 'direction' parameter controls whether the angle is measured
|
|
positive above the horizon or positive below the horizon,
|
|
depending on whether the caller wants rise times or set times, respectively.
|
|
*/
|
|
|
|
ofdate = Astronomy_Equator(p->body, &time, p->observer, EQUATOR_OF_DATE, ABERRATION);
|
|
if (ofdate.status != ASTRO_SUCCESS)
|
|
return FuncError(ofdate.status);
|
|
|
|
/* We calculate altitude without refraction, then add fixed refraction near the horizon. */
|
|
/* This gives us the time of rise/set without the extra work. */
|
|
hor = Astronomy_Horizon(&time, p->observer, ofdate.ra, ofdate.dec, REFRACTION_NONE);
|
|
result.value = p->direction * (hor.altitude + RAD2DEG*(p->body_radius_au / ofdate.dist) + REFRACTION_NEAR_HORIZON);
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Searches for the next time a celestial body rises or sets as seen by an observer on the Earth.
|
|
*
|
|
* This function finds the next rise or set time of the Sun, Moon, or planet other than the Earth.
|
|
* Rise time is when the body first starts to be visible above the horizon.
|
|
* For example, sunrise is the moment that the top of the Sun first appears to peek above the horizon.
|
|
* Set time is the moment when the body appears to vanish below the horizon.
|
|
*
|
|
* This function corrects for typical atmospheric refraction, which causes celestial
|
|
* bodies to appear higher above the horizon than they would if the Earth had no atmosphere.
|
|
* It also adjusts for the apparent angular radius of the observed body (significant only for the Sun and Moon).
|
|
*
|
|
* Note that rise or set may not occur in every 24 hour period.
|
|
* For example, near the Earth's poles, there are long periods of time where
|
|
* the Sun stays below the horizon, never rising.
|
|
* Also, it is possible for the Moon to rise just before midnight but not set during the subsequent 24-hour day.
|
|
* This is because the Moon sets nearly an hour later each day due to orbiting the Earth a
|
|
* significant amount during each rotation of the Earth.
|
|
* Therefore callers must not assume that the function will always succeed.
|
|
*
|
|
* @param body
|
|
* The Sun, Moon, or any planet other than the Earth.
|
|
*
|
|
* @param observer
|
|
* The location where observation takes place.
|
|
* You can create an observer structure by calling #Astronomy_MakeObserver.
|
|
*
|
|
* @param direction
|
|
* Either `DIRECTION_RISE` to find a rise time or `DIRECTION_SET` to find a set time.
|
|
*
|
|
* @param startTime
|
|
* The date and time at which to start the search.
|
|
*
|
|
* @param limitDays
|
|
* Limits how many days to search for a rise or set time.
|
|
* To limit a rise or set time to the same day, you can use a value of 1 day.
|
|
* In cases where you want to find the next rise or set time no matter how far
|
|
* in the future (for example, for an observer near the south pole), you can
|
|
* pass in a larger value like 365.
|
|
*
|
|
* @return
|
|
* On success, the `status` field in the returned structure contains `ASTRO_SUCCESS`
|
|
* and the `time` field contains the date and time of the rise or set time as requested.
|
|
* If the `status` field contains `ASTRO_SEARCH_FAILURE`, it means the rise or set
|
|
* event does not occur within `limitDays` days of `startTime`. This is a normal condition,
|
|
* not an error. Any other value of `status` indicates an error of some kind.
|
|
*/
|
|
astro_search_result_t Astronomy_SearchRiseSet(
|
|
astro_body_t body,
|
|
astro_observer_t observer,
|
|
astro_direction_t direction,
|
|
astro_time_t startTime,
|
|
double limitDays)
|
|
{
|
|
context_peak_altitude_t context;
|
|
double ha_before, ha_after;
|
|
astro_time_t time_start, time_before;
|
|
astro_func_result_t alt_before, alt_after;
|
|
astro_hour_angle_t evt_before, evt_after;
|
|
|
|
if (body == BODY_EARTH)
|
|
return SearchError(ASTRO_EARTH_NOT_ALLOWED);
|
|
|
|
switch (direction)
|
|
{
|
|
case DIRECTION_RISE:
|
|
ha_before = 12.0; /* minimum altitude (bottom) happens BEFORE the body rises. */
|
|
ha_after = 0.0; /* maximum altitude (culmination) happens AFTER the body rises. */
|
|
break;
|
|
|
|
case DIRECTION_SET:
|
|
ha_before = 0.0; /* culmination happens BEFORE the body sets. */
|
|
ha_after = 12.0; /* bottom happens AFTER the body sets. */
|
|
break;
|
|
|
|
default:
|
|
return SearchError(ASTRO_INVALID_PARAMETER);
|
|
}
|
|
|
|
/* Set up the context structure for the search function 'peak_altitude'. */
|
|
context.body = body;
|
|
context.direction = (int)direction;
|
|
context.observer = observer;
|
|
switch (body)
|
|
{
|
|
case BODY_SUN: context.body_radius_au = SUN_RADIUS_AU; break;
|
|
case BODY_MOON: context.body_radius_au = MOON_EQUATORIAL_RADIUS_AU; break;
|
|
default: context.body_radius_au = 0.0; break;
|
|
}
|
|
|
|
/*
|
|
See if the body is currently above/below the horizon.
|
|
If we are looking for next rise time and the body is below the horizon,
|
|
we use the current time as the lower time bound and the next culmination
|
|
as the upper bound.
|
|
If the body is above the horizon, we search for the next bottom and use it
|
|
as the lower bound and the next culmination after that bottom as the upper bound.
|
|
The same logic applies for finding set times, only we swap the hour angles.
|
|
*/
|
|
|
|
time_start = startTime;
|
|
alt_before = peak_altitude(&context, time_start);
|
|
if (alt_before.status != ASTRO_SUCCESS)
|
|
return SearchError(alt_before.status);
|
|
|
|
if (alt_before.value > 0.0)
|
|
{
|
|
/* We are past the sought event, so we have to wait for the next "before" event (culm/bottom). */
|
|
evt_before = Astronomy_SearchHourAngle(body, observer, ha_before, time_start);
|
|
if (evt_before.status != ASTRO_SUCCESS)
|
|
return SearchError(evt_before.status);
|
|
|
|
time_before = evt_before.time;
|
|
|
|
alt_before = peak_altitude(&context, time_before);
|
|
if (alt_before.status != ASTRO_SUCCESS)
|
|
return SearchError(alt_before.status);
|
|
}
|
|
else
|
|
{
|
|
/* We are before or at the sought event, so we find the next "after" event (bottom/culm), */
|
|
/* and use the current time as the "before" event. */
|
|
time_before = time_start;
|
|
}
|
|
|
|
evt_after = Astronomy_SearchHourAngle(body, observer, ha_after, time_before);
|
|
if (evt_after.status != ASTRO_SUCCESS)
|
|
return SearchError(evt_after.status);
|
|
|
|
alt_after = peak_altitude(&context, evt_after.time);
|
|
if (alt_after.status != ASTRO_SUCCESS)
|
|
return SearchError(alt_after.status);
|
|
|
|
for(;;)
|
|
{
|
|
if (alt_before.value <= 0.0 && alt_after.value > 0.0)
|
|
{
|
|
/* Search between evt_before and evt_after for the desired event. */
|
|
astro_search_result_t result = Astronomy_Search(peak_altitude, &context, time_before, evt_after.time, 1.0);
|
|
|
|
/* ASTRO_SEARCH_FAILURE is a special error that indicates a normal lack of finding a solution. */
|
|
/* If successful, or any other error, return immediately. */
|
|
if (result.status != ASTRO_SEARCH_FAILURE)
|
|
return result;
|
|
}
|
|
|
|
/* If we didn't find the desired event, use evt_after.time to find the next before-event. */
|
|
evt_before = Astronomy_SearchHourAngle(body, observer, ha_before, evt_after.time);
|
|
if (evt_before.status != ASTRO_SUCCESS)
|
|
return SearchError(evt_before.status);
|
|
|
|
evt_after = Astronomy_SearchHourAngle(body, observer, ha_after, evt_before.time);
|
|
if (evt_after.status != ASTRO_SUCCESS)
|
|
return SearchError(evt_after.status);
|
|
|
|
if (evt_before.time.ut >= time_start.ut + limitDays)
|
|
return SearchError(ASTRO_SEARCH_FAILURE);
|
|
|
|
time_before = evt_before.time;
|
|
|
|
alt_before = peak_altitude(&context, evt_before.time);
|
|
if (alt_before.status != ASTRO_SUCCESS)
|
|
return SearchError(alt_before.status);
|
|
|
|
alt_after = peak_altitude(&context, evt_after.time);
|
|
if (alt_after.status != ASTRO_SUCCESS)
|
|
return SearchError(alt_after.status);
|
|
}
|
|
}
|
|
|
|
static double MoonMagnitude(double phase, double helio_dist, double geo_dist)
|
|
{
|
|
/* https://astronomy.stackexchange.com/questions/10246/is-there-a-simple-analytical-formula-for-the-lunar-phase-brightness-curve */
|
|
double rad = phase * DEG2RAD;
|
|
double rad2 = rad * rad;
|
|
double rad4 = rad2 * rad2;
|
|
double mag = -12.717 + 1.49*fabs(rad) + 0.0431*rad4;
|
|
double moon_mean_distance_au = 385000.6 / KM_PER_AU;
|
|
double geo_au = geo_dist / moon_mean_distance_au;
|
|
mag += 5*log10(helio_dist * geo_au);
|
|
return mag;
|
|
}
|
|
|
|
static astro_status_t SaturnMagnitude(
|
|
double phase,
|
|
double helio_dist,
|
|
double geo_dist,
|
|
astro_vector_t gc,
|
|
astro_time_t time,
|
|
double *mag,
|
|
double *ring_tilt)
|
|
{
|
|
astro_ecliptic_t eclip;
|
|
double ir, Nr, lat, lon, tilt, sin_tilt;
|
|
|
|
*mag = *ring_tilt = NAN;
|
|
|
|
/* Based on formulas by Paul Schlyter found here: */
|
|
/* http://www.stjarnhimlen.se/comp/ppcomp.html#15 */
|
|
|
|
/* We must handle Saturn's rings as a major component of its visual magnitude. */
|
|
/* Find geocentric ecliptic coordinates of Saturn. */
|
|
eclip = Astronomy_Ecliptic(gc);
|
|
if (eclip.status != ASTRO_SUCCESS)
|
|
return eclip.status;
|
|
|
|
ir = DEG2RAD * 28.06; /* tilt of Saturn's rings to the ecliptic, in radians */
|
|
Nr = DEG2RAD * (169.51 + (3.82e-5 * time.tt)); /* ascending node of Saturn's rings, in radians */
|
|
|
|
/* Find tilt of Saturn's rings, as seen from Earth. */
|
|
lat = DEG2RAD * eclip.elat;
|
|
lon = DEG2RAD * eclip.elon;
|
|
tilt = asin(sin(lat)*cos(ir) - cos(lat)*sin(ir)*sin(lon-Nr));
|
|
sin_tilt = sin(fabs(tilt));
|
|
|
|
*mag = -9.0 + 0.044*phase;
|
|
*mag += sin_tilt*(-2.6 + 1.2*sin_tilt);
|
|
*mag += 5.0 * log10(helio_dist * geo_dist);
|
|
|
|
*ring_tilt = RAD2DEG * tilt;
|
|
|
|
return ASTRO_SUCCESS;
|
|
}
|
|
|
|
static astro_status_t VisualMagnitude(
|
|
astro_body_t body,
|
|
double phase,
|
|
double helio_dist,
|
|
double geo_dist,
|
|
double *mag)
|
|
{
|
|
/* For Mercury and Venus, see: https://iopscience.iop.org/article/10.1086/430212 */
|
|
double c0, c1=0, c2=0, c3=0, x;
|
|
*mag = NAN;
|
|
switch (body)
|
|
{
|
|
case BODY_MERCURY: c0 = -0.60, c1 = +4.98, c2 = -4.88, c3 = +3.02; break;
|
|
case BODY_VENUS:
|
|
if (phase < 163.6)
|
|
c0 = -4.47, c1 = +1.03, c2 = +0.57, c3 = +0.13;
|
|
else
|
|
c0 = 0.98, c1 = -1.02;
|
|
break;
|
|
case BODY_MARS: c0 = -1.52, c1 = +1.60; break;
|
|
case BODY_JUPITER: c0 = -9.40, c1 = +0.50; break;
|
|
case BODY_URANUS: c0 = -7.19, c1 = +0.25; break;
|
|
case BODY_NEPTUNE: c0 = -6.87; break;
|
|
case BODY_PLUTO: c0 = -1.00, c1 = +4.00; break;
|
|
default: return ASTRO_INVALID_BODY;
|
|
}
|
|
|
|
x = phase / 100;
|
|
*mag = c0 + x*(c1 + x*(c2 + x*c3));
|
|
*mag += 5.0 * log10(helio_dist * geo_dist);
|
|
return ASTRO_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Finds visual magnitude, phase angle, and other illumination information about a celestial body.
|
|
*
|
|
* This function calculates information about how bright a celestial body appears from the Earth,
|
|
* reported as visual magnitude, which is a smaller (or even negative) number for brighter objects
|
|
* and a larger number for dimmer objects.
|
|
*
|
|
* For bodies other than the Sun, it reports a phase angle, which is the angle in degrees between
|
|
* the Sun and the Earth, as seen from the center of the body. Phase angle indicates what fraction
|
|
* of the body appears illuminated as seen from the Earth. For example, when the phase angle is
|
|
* near zero, it means the body appears "full" as seen from the Earth. A phase angle approaching
|
|
* 180 degrees means the body appears as a thin crescent as seen from the Earth. A phase angle
|
|
* of 90 degrees means the body appears "half full".
|
|
* For the Sun, the phase angle is always reported as 0; the Sun emits light rather than reflecting it,
|
|
* so it doesn't have a phase angle.
|
|
*
|
|
* When the body is Saturn, the returned structure contains a field `ring_tilt` that holds
|
|
* the tilt angle in degrees of Saturn's rings as seen from the Earth. A value of 0 means
|
|
* the rings appear edge-on, and are thus nearly invisible from the Earth. The `ring_tilt` holds
|
|
* 0 for all bodies other than Saturn.
|
|
*
|
|
* @param body
|
|
* The Sun, Moon, or any planet other than the Earth.
|
|
*
|
|
* @param time
|
|
* The date and time of the observation.
|
|
*
|
|
* @return
|
|
* On success, the `status` field of the return structure holds `ASTRO_SUCCESS`
|
|
* and the other structure fields are valid.
|
|
* Any other value indicates an error, in which case the remaining structure fields are not valid.
|
|
*/
|
|
astro_illum_t Astronomy_Illumination(astro_body_t body, astro_time_t time)
|
|
{
|
|
astro_vector_t earth; /* vector from Sun to Earth */
|
|
astro_vector_t hc; /* vector from Sun to body */
|
|
astro_vector_t gc; /* vector from Earth to body */
|
|
double mag; /* visual magnitude */
|
|
astro_angle_result_t phase; /* phase angle in degrees between Earth and Sun as seen from body */
|
|
double helio_dist; /* distance from Sun to body */
|
|
double geo_dist; /* distance from Earth to body */
|
|
double ring_tilt = 0.0; /* Saturn's ring tilt (0 for all other bodies) */
|
|
astro_illum_t illum;
|
|
astro_status_t status;
|
|
|
|
if (body == BODY_EARTH)
|
|
return IllumError(ASTRO_EARTH_NOT_ALLOWED);
|
|
|
|
earth = CalcEarth(time);
|
|
if (earth.status != ASTRO_SUCCESS)
|
|
return IllumError(earth.status);
|
|
|
|
if (body == BODY_SUN)
|
|
{
|
|
gc.status = ASTRO_SUCCESS;
|
|
gc.t = time;
|
|
gc.x = -earth.x;
|
|
gc.y = -earth.y;
|
|
gc.z = -earth.z;
|
|
|
|
hc.status = ASTRO_SUCCESS;
|
|
hc.t = time;
|
|
hc.x = 0.0;
|
|
hc.y = 0.0;
|
|
hc.z = 0.0;
|
|
|
|
/* The Sun emits light instead of reflecting it, */
|
|
/* so we report a placeholder phase angle of 0. */
|
|
phase.status = ASTRO_SUCCESS;
|
|
phase.angle = 0.0;
|
|
}
|
|
else
|
|
{
|
|
if (body == BODY_MOON)
|
|
{
|
|
/* For extra numeric precision, use geocentric Moon formula directly. */
|
|
gc = Astronomy_GeoMoon(time);
|
|
if (gc.status != ASTRO_SUCCESS)
|
|
return IllumError(gc.status);
|
|
|
|
hc.status = ASTRO_SUCCESS;
|
|
hc.t = time;
|
|
hc.x = earth.x + gc.x;
|
|
hc.y = earth.y + gc.y;
|
|
hc.z = earth.z + gc.z;
|
|
}
|
|
else
|
|
{
|
|
/* For planets, the heliocentric vector is more direct to calculate. */
|
|
hc = Astronomy_HelioVector(body, time);
|
|
if (hc.status != ASTRO_SUCCESS)
|
|
return IllumError(hc.status);
|
|
|
|
gc.status = ASTRO_SUCCESS;
|
|
gc.t = time;
|
|
gc.x = hc.x - earth.x;
|
|
gc.y = hc.y - earth.y;
|
|
gc.z = hc.z - earth.z;
|
|
}
|
|
|
|
phase = AngleBetween(gc, hc);
|
|
if (phase.status != ASTRO_SUCCESS)
|
|
return IllumError(phase.status);
|
|
}
|
|
|
|
geo_dist = Astronomy_VectorLength(gc);
|
|
helio_dist = Astronomy_VectorLength(hc);
|
|
|
|
switch (body)
|
|
{
|
|
case BODY_SUN:
|
|
mag = -0.17 + 5.0*log10(geo_dist / AU_PER_PARSEC);
|
|
break;
|
|
|
|
case BODY_MOON:
|
|
mag = MoonMagnitude(phase.angle, helio_dist, geo_dist);
|
|
break;
|
|
|
|
case BODY_SATURN:
|
|
status = SaturnMagnitude(phase.angle, helio_dist, geo_dist, gc, time, &mag, &ring_tilt);
|
|
if (status != ASTRO_SUCCESS)
|
|
return IllumError(status);
|
|
break;
|
|
|
|
default:
|
|
status = VisualMagnitude(body, phase.angle, helio_dist, geo_dist, &mag);
|
|
break;
|
|
}
|
|
|
|
illum.status = ASTRO_SUCCESS;
|
|
illum.time = time;
|
|
illum.mag = mag;
|
|
illum.phase_angle = phase.angle;
|
|
illum.helio_dist = helio_dist;
|
|
illum.ring_tilt = ring_tilt;
|
|
|
|
return illum;
|
|
}
|
|
|
|
static astro_func_result_t mag_slope(void *context, astro_time_t time)
|
|
{
|
|
/*
|
|
The Search() function finds a transition from negative to positive values.
|
|
The derivative of magnitude y with respect to time t (dy/dt)
|
|
is negative as an object gets brighter, because the magnitude numbers
|
|
get smaller. At peak magnitude dy/dt = 0, then as the object gets dimmer,
|
|
dy/dt > 0.
|
|
*/
|
|
static const double dt = 0.01;
|
|
astro_illum_t y1, y2;
|
|
astro_body_t body = *((astro_body_t *)context);
|
|
astro_time_t t1 = Astronomy_AddDays(time, -dt/2);
|
|
astro_time_t t2 = Astronomy_AddDays(time, +dt/2);
|
|
astro_func_result_t result;
|
|
|
|
y1 = Astronomy_Illumination(body, t1);
|
|
if (y1.status != ASTRO_SUCCESS)
|
|
return FuncError(y1.status);
|
|
|
|
y2 = Astronomy_Illumination(body, t2);
|
|
if (y2.status != ASTRO_SUCCESS)
|
|
return FuncError(y2.status);
|
|
|
|
result.value = (y2.mag - y1.mag) / dt;
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Searches for the date and time Venus will next appear brightest as seen from the Earth.
|
|
*
|
|
* This function searches for the date and time Venus appears brightest as seen from the Earth.
|
|
* Currently only Venus is supported for the `body` parameter, though this could change in the future.
|
|
* Mercury's peak magnitude occurs at superior conjunction, when it is virtually impossible to see from the Earth,
|
|
* so peak magnitude events have little practical value for that planet.
|
|
* Planets other than Venus and Mercury reach peak magnitude at opposition, which can
|
|
* be found using #Astronomy_SearchRelativeLongitude.
|
|
* The Moon reaches peak magnitude at full moon, which can be found using
|
|
* #Astronomy_SearchMoonQuarter or #Astronomy_SearchMoonPhase.
|
|
* The Sun reaches peak magnitude at perihelion, which occurs each year in January.
|
|
* However, the difference is minor and has little practical value.
|
|
*
|
|
* @param body
|
|
* Currently only `BODY_VENUS` is allowed. Any other value results in the error `ASTRO_INVALID_BODY`.
|
|
* See function remarks for more details.
|
|
*
|
|
* @param startTime
|
|
* The date and time to start searching for the next peak magnitude event.
|
|
*
|
|
* @return
|
|
* See documentation about the return value from #Astronomy_Illumination.
|
|
*/
|
|
astro_illum_t Astronomy_SearchPeakMagnitude(astro_body_t body, astro_time_t startTime)
|
|
{
|
|
/* s1 and s2 are relative longitudes within which peak magnitude of Venus can occur. */
|
|
static const double s1 = 10.0;
|
|
static const double s2 = 30.0;
|
|
int iter;
|
|
astro_angle_result_t plon, elon;
|
|
astro_search_result_t t1, t2, tx;
|
|
astro_func_result_t syn, m1, m2;
|
|
astro_time_t t_start;
|
|
double rlon, rlon_lo, rlon_hi, adjust_days;
|
|
|
|
if (body != BODY_VENUS)
|
|
return IllumError(ASTRO_INVALID_BODY);
|
|
|
|
iter = 0;
|
|
while (++iter <= 2)
|
|
{
|
|
/* Find current heliocentric relative longitude between the */
|
|
/* inferior planet and the Earth. */
|
|
plon = Astronomy_EclipticLongitude(body, startTime);
|
|
if (plon.status != ASTRO_SUCCESS)
|
|
return IllumError(plon.status);
|
|
|
|
elon = Astronomy_EclipticLongitude(BODY_EARTH, startTime);
|
|
if (elon.status != ASTRO_SUCCESS)
|
|
return IllumError(elon.status);
|
|
|
|
rlon = LongitudeOffset(plon.angle - elon.angle); /* clamp to (-180, +180]. */
|
|
|
|
/* The slope function is not well-behaved when rlon is near 0 degrees or 180 degrees */
|
|
/* because there is a cusp there that causes a discontinuity in the derivative. */
|
|
/* So we need to guard against searching near such times. */
|
|
|
|
if (rlon >= -s1 && rlon < +s1)
|
|
{
|
|
/* Seek to the window [+s1, +s2]. */
|
|
adjust_days = 0.0;
|
|
/* Search forward for the time t1 when rel lon = +s1. */
|
|
rlon_lo = +s1;
|
|
/* Search forward for the time t2 when rel lon = +s2. */
|
|
rlon_hi = +s2;
|
|
}
|
|
else if (rlon >= +s2 || rlon < -s2)
|
|
{
|
|
/* Seek to the next search window at [-s2, -s1]. */
|
|
adjust_days = 0.0;
|
|
/* Search forward for the time t1 when rel lon = -s2. */
|
|
rlon_lo = -s2;
|
|
/* Search forward for the time t2 when rel lon = -s1. */
|
|
rlon_hi = -s1;
|
|
}
|
|
else if (rlon >= 0)
|
|
{
|
|
/* rlon must be in the middle of the window [+s1, +s2]. */
|
|
/* Search BACKWARD for the time t1 when rel lon = +s1. */
|
|
syn = SynodicPeriod(body);
|
|
if (syn.status != ASTRO_SUCCESS)
|
|
return IllumError(syn.status);
|
|
adjust_days = -syn.value / 4;
|
|
rlon_lo = +s1;
|
|
/* Search forward from t1 to find t2 such that rel lon = +s2. */
|
|
rlon_hi = +s2;
|
|
}
|
|
else
|
|
{
|
|
/* rlon must be in the middle of the window [-s2, -s1]. */
|
|
/* Search BACKWARD for the time t1 when rel lon = -s2. */
|
|
syn = SynodicPeriod(body);
|
|
if (syn.status != ASTRO_SUCCESS)
|
|
return IllumError(syn.status);
|
|
adjust_days = -syn.value / 4;
|
|
rlon_lo = -s2;
|
|
/* Search forward from t1 to find t2 such that rel lon = -s1. */
|
|
rlon_hi = -s1;
|
|
}
|
|
t_start = Astronomy_AddDays(startTime, adjust_days);
|
|
t1 = Astronomy_SearchRelativeLongitude(body, rlon_lo, t_start);
|
|
if (t1.status != ASTRO_SUCCESS)
|
|
return IllumError(t1.status);
|
|
t2 = Astronomy_SearchRelativeLongitude(body, rlon_hi, t1.time);
|
|
if (t2.status != ASTRO_SUCCESS)
|
|
return IllumError(t2.status);
|
|
|
|
/* Now we have a time range [t1,t2] that brackets a maximum magnitude event. */
|
|
/* Confirm the bracketing. */
|
|
m1 = mag_slope(&body, t1.time);
|
|
if (m1.status != ASTRO_SUCCESS)
|
|
return IllumError(m1.status);
|
|
if (m1.value >= 0.0)
|
|
return IllumError(ASTRO_INTERNAL_ERROR); /* should never happen! */
|
|
|
|
m2 = mag_slope(&body, t2.time);
|
|
if (m2.status != ASTRO_SUCCESS)
|
|
return IllumError(m2.status);
|
|
if (m2.value <= 0.0)
|
|
return IllumError(ASTRO_INTERNAL_ERROR); /* should never happen! */
|
|
|
|
/* Use the generic search algorithm to home in on where the slope crosses from negative to positive. */
|
|
tx = Astronomy_Search(mag_slope, &body, t1.time, t2.time, 10.0);
|
|
if (tx.status != ASTRO_SUCCESS)
|
|
return IllumError(tx.status);
|
|
|
|
if (tx.time.tt >= startTime.tt)
|
|
return Astronomy_Illumination(body, tx.time);
|
|
|
|
/* This event is in the past (earlier than startTime). */
|
|
/* We need to search forward from t2 to find the next possible window. */
|
|
/* We never need to search more than twice. */
|
|
startTime = Astronomy_AddDays(t2.time, 1.0);
|
|
}
|
|
|
|
return IllumError(ASTRO_SEARCH_FAILURE);
|
|
}
|
|
|
|
static double MoonDistance(astro_time_t t)
|
|
{
|
|
double lon, lat, dist;
|
|
CalcMoon(t.tt / 36525.0, &lon, &lat, &dist);
|
|
return dist;
|
|
}
|
|
|
|
static astro_func_result_t moon_distance_slope(void *context, astro_time_t time)
|
|
{
|
|
static const double dt = 0.001;
|
|
astro_time_t t1 = Astronomy_AddDays(time, -dt/2.0);
|
|
astro_time_t t2 = Astronomy_AddDays(time, +dt/2.0);
|
|
double dist1, dist2;
|
|
int direction = *((int *)context);
|
|
astro_func_result_t result;
|
|
|
|
dist1 = MoonDistance(t1);
|
|
dist2 = MoonDistance(t2);
|
|
result.value = direction * (dist2 - dist1) / dt;
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Finds the date and time of the Moon's closest distance (perigee)
|
|
* or farthest distance (apogee) with respect to the Earth.
|
|
*
|
|
* Given a date and time to start the search in `startTime`, this function finds the
|
|
* next date and time that the center of the Moon reaches the closest or farthest point
|
|
* in its orbit with respect to the center of the Earth, whichever comes first
|
|
* after `startTime`.
|
|
*
|
|
* The closest point is called *perigee* and the farthest point is called *apogee*.
|
|
* The word *apsis* refers to either event.
|
|
*
|
|
* To iterate through consecutive alternating perigee and apogee events, call `Astronomy_SearchLunarApsis`
|
|
* once, then use the return value to call #Astronomy_NextLunarApsis. After that,
|
|
* keep feeding the previous return value from `Astronomy_NextLunarApsis` into another
|
|
* call of `Astronomy_NextLunarApsis` as many times as desired.
|
|
*
|
|
* @param startTime
|
|
* The date and time at which to start searching for the next perigee or apogee.
|
|
*
|
|
* @return
|
|
* If successful, the `status` field in the returned structure holds `ASTRO_SUCCESS`,
|
|
* `time` holds the date and time of the next lunar apsis, `kind` holds either
|
|
* `APSIS_PERICENTER` for perigee or `APSIS_APOCENTER` for apogee, and the distance
|
|
* values `dist_au` (astronomical units) and `dist_km` (kilometers) are valid.
|
|
* If the function fails, `status` holds some value other than `ASTRO_SUCCESS` that
|
|
* indicates what went wrong, and the other structure fields are invalid.
|
|
*/
|
|
astro_apsis_t Astronomy_SearchLunarApsis(astro_time_t startTime)
|
|
{
|
|
astro_time_t t1, t2;
|
|
astro_search_result_t search;
|
|
astro_func_result_t m1, m2;
|
|
int positive_direction = +1;
|
|
int negative_direction = -1;
|
|
const double increment = 5.0; /* number of days to skip in each iteration */
|
|
astro_apsis_t result;
|
|
int iter;
|
|
|
|
/*
|
|
Check the rate of change of the distance dr/dt at the start time.
|
|
If it is positive, the Moon is currently getting farther away,
|
|
so start looking for apogee.
|
|
Conversely, if dr/dt < 0, start looking for perigee.
|
|
Either way, the polarity of the slope will change, so the product will be negative.
|
|
Handle the crazy corner case of exactly touching zero by checking for m1*m2 <= 0.
|
|
*/
|
|
|
|
t1 = startTime;
|
|
m1 = moon_distance_slope(&positive_direction, t1);
|
|
if (m1.status != ASTRO_SUCCESS)
|
|
return ApsisError(m1.status);
|
|
|
|
for (iter=0; iter * increment < 2.0 * MEAN_SYNODIC_MONTH; ++iter)
|
|
{
|
|
t2 = Astronomy_AddDays(t1, increment);
|
|
m2 = moon_distance_slope(&positive_direction, t2);
|
|
if (m2.status != ASTRO_SUCCESS)
|
|
return ApsisError(m2.status);
|
|
|
|
if (m1.value * m2.value <= 0.0)
|
|
{
|
|
/* There is a change of slope polarity within the time range [t1, t2]. */
|
|
/* Therefore this time range contains an apsis. */
|
|
/* Figure out whether it is perigee or apogee. */
|
|
|
|
if (m1.value < 0.0 || m2.value > 0.0)
|
|
{
|
|
/* We found a minimum-distance event: perigee. */
|
|
/* Search the time range for the time when the slope goes from negative to positive. */
|
|
search = Astronomy_Search(moon_distance_slope, &positive_direction, t1, t2, 1.0);
|
|
result.kind = APSIS_PERICENTER;
|
|
}
|
|
else if (m1.value > 0.0 || m2.value < 0.0)
|
|
{
|
|
/* We found a maximum-distance event: apogee. */
|
|
/* Search the time range for the time when the slope goes from positive to negative. */
|
|
search = Astronomy_Search(moon_distance_slope, &negative_direction, t1, t2, 1.0);
|
|
result.kind = APSIS_APOCENTER;
|
|
}
|
|
else
|
|
{
|
|
/* This should never happen. It should not be possible for both slopes to be zero. */
|
|
return ApsisError(ASTRO_INTERNAL_ERROR);
|
|
}
|
|
|
|
if (search.status != ASTRO_SUCCESS)
|
|
return ApsisError(search.status);
|
|
|
|
result.status = ASTRO_SUCCESS;
|
|
result.time = search.time;
|
|
result.dist_au = MoonDistance(search.time);
|
|
result.dist_km = result.dist_au * KM_PER_AU;
|
|
return result;
|
|
}
|
|
|
|
/* We have not yet found a slope polarity change. Keep searching. */
|
|
t1 = t2;
|
|
m1 = m2;
|
|
}
|
|
|
|
/* It should not be possible to fail to find an apsis within 2 synodic months. */
|
|
return ApsisError(ASTRO_INTERNAL_ERROR);
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Finds the next lunar perigee or apogee event in a series.
|
|
*
|
|
* This function requires an #astro_apsis_t value obtained from a call
|
|
* to #Astronomy_SearchLunarApsis or `Astronomy_NextLunarApsis`. Given
|
|
* an apogee event, this function finds the next perigee event, and vice versa.
|
|
*
|
|
* See #Astronomy_SearchLunarApsis for more details.
|
|
*
|
|
* @param apsis
|
|
* An apsis event obtained from a call to #Astronomy_SearchLunarApsis or `Astronomy_NextLunarApsis`.
|
|
* See #Astronomy_SearchLunarApsis for more details.
|
|
*
|
|
* @return
|
|
* Same as the return value for #Astronomy_SearchLunarApsis.
|
|
*/
|
|
astro_apsis_t Astronomy_NextLunarApsis(astro_apsis_t apsis)
|
|
{
|
|
static const double skip = 11.0; /* number of days to skip to start looking for next apsis event */
|
|
astro_apsis_t next;
|
|
astro_time_t time;
|
|
|
|
if (apsis.status != ASTRO_SUCCESS)
|
|
return ApsisError(ASTRO_INVALID_PARAMETER);
|
|
|
|
if (apsis.kind != APSIS_APOCENTER && apsis.kind != APSIS_PERICENTER)
|
|
return ApsisError(ASTRO_INVALID_PARAMETER);
|
|
|
|
time = Astronomy_AddDays(apsis.time, skip);
|
|
next = Astronomy_SearchLunarApsis(time);
|
|
if (next.status == ASTRO_SUCCESS)
|
|
{
|
|
/* Verify that we found the opposite apsis from the previous one. */
|
|
if (next.kind + apsis.kind != 1)
|
|
return ApsisError(ASTRO_INTERNAL_ERROR);
|
|
}
|
|
return next;
|
|
}
|
|
|
|
|
|
/** @cond DOXYGEN_SKIP */
|
|
typedef struct
|
|
{
|
|
int direction;
|
|
astro_body_t body;
|
|
}
|
|
planet_distance_context_t;
|
|
/** @endcond */
|
|
|
|
|
|
static astro_func_result_t planet_distance_slope(void *context, astro_time_t time)
|
|
{
|
|
static const double dt = 0.001;
|
|
const planet_distance_context_t *pc = context;
|
|
astro_time_t t1 = Astronomy_AddDays(time, -dt/2.0);
|
|
astro_time_t t2 = Astronomy_AddDays(time, +dt/2.0);
|
|
astro_func_result_t dist1, dist2, result;
|
|
|
|
dist1 = Astronomy_HelioDistance(pc->body, t1);
|
|
if (dist1.status != ASTRO_SUCCESS)
|
|
return dist1;
|
|
|
|
dist2 = Astronomy_HelioDistance(pc->body, t2);
|
|
if (dist2.status != ASTRO_SUCCESS)
|
|
return dist2;
|
|
|
|
result.value = pc->direction * (dist2.value - dist1.value) / dt;
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
static astro_apsis_t PlanetExtreme(
|
|
astro_body_t body,
|
|
astro_apsis_kind_t kind,
|
|
astro_time_t start_time,
|
|
double dayspan)
|
|
{
|
|
astro_apsis_t apsis;
|
|
const double direction = (kind == APSIS_APOCENTER) ? +1.0 : -1.0;
|
|
const int npoints = 10;
|
|
int i, best_i;
|
|
double interval;
|
|
double dist, best_dist;
|
|
astro_time_t time;
|
|
astro_func_result_t result;
|
|
|
|
for(;;)
|
|
{
|
|
interval = dayspan / (npoints - 1);
|
|
|
|
if (interval < 1.0 / 1440.0) /* iterate until uncertainty is less than one minute */
|
|
{
|
|
apsis.status = ASTRO_SUCCESS;
|
|
apsis.kind = kind;
|
|
apsis.time = Astronomy_AddDays(start_time, interval / 2.0);
|
|
result = Astronomy_HelioDistance(body, apsis.time);
|
|
if (result.status != ASTRO_SUCCESS)
|
|
return ApsisError(result.status);
|
|
apsis.dist_au = result.value;
|
|
apsis.dist_km = apsis.dist_au * KM_PER_AU;
|
|
return apsis;
|
|
}
|
|
|
|
best_i = -1;
|
|
best_dist = 0.0;
|
|
for (i=0; i < npoints; ++i)
|
|
{
|
|
time = Astronomy_AddDays(start_time, i * interval);
|
|
result = Astronomy_HelioDistance(body, time);
|
|
if (result.status != ASTRO_SUCCESS)
|
|
return ApsisError(result.status);
|
|
dist = direction * result.value;
|
|
if (i==0 || dist > best_dist)
|
|
{
|
|
best_i = i;
|
|
best_dist = dist;
|
|
}
|
|
}
|
|
|
|
/* Narrow in on the extreme point. */
|
|
start_time = Astronomy_AddDays(start_time, (best_i - 1) * interval);
|
|
dayspan = 2.0 * interval;
|
|
}
|
|
}
|
|
|
|
|
|
static astro_apsis_t BruteSearchPlanetApsis(astro_body_t body, astro_time_t startTime)
|
|
{
|
|
const int npoints = 100;
|
|
int i;
|
|
astro_time_t t1, t2, time, t_min, t_max;
|
|
double dist, max_dist, min_dist;
|
|
astro_apsis_t perihelion, aphelion;
|
|
double interval;
|
|
double period;
|
|
astro_func_result_t result;
|
|
|
|
/*
|
|
Neptune is a special case for two reasons:
|
|
1. Its orbit is nearly circular (low orbital eccentricity).
|
|
2. It is so distant from the Sun that the orbital period is very long.
|
|
Put together, this causes wobbling of the Sun around the Solar System Barycenter (SSB)
|
|
to be so significant that there are 3 local minima in the distance-vs-time curve
|
|
near each apsis. Therefore, unlike for other planets, we can't use an optimized
|
|
algorithm for finding dr/dt = 0.
|
|
Instead, we use a dumb, brute-force algorithm of sampling and finding min/max
|
|
heliocentric distance.
|
|
|
|
There is a similar problem in the TOP2013 model for Pluto:
|
|
Its position vector has high-frequency oscillations that confuse the
|
|
slope-based determination of apsides.
|
|
*/
|
|
|
|
/*
|
|
Rewind approximately 30 degrees in the orbit,
|
|
then search forward for 270 degrees.
|
|
This is a very cautious way to prevent missing an apsis.
|
|
Typically we will find two apsides, and we pick whichever
|
|
apsis is ealier, but after startTime.
|
|
Sample points around this orbital arc and find when the distance
|
|
is greatest and smallest.
|
|
*/
|
|
period = PlanetOrbitalPeriod(body);
|
|
t1 = Astronomy_AddDays(startTime, period * ( -30.0 / 360.0));
|
|
t2 = Astronomy_AddDays(startTime, period * (+270.0 / 360.0));
|
|
t_min = t_max = t1;
|
|
min_dist = max_dist = -1.0; /* prevent warning about uninitialized variables */
|
|
interval = (t2.ut - t1.ut) / (npoints - 1.0);
|
|
|
|
for (i=0; i < npoints; ++i)
|
|
{
|
|
double ut = t1.ut + (i * interval);
|
|
time = Astronomy_TimeFromDays(ut);
|
|
result = Astronomy_HelioDistance(body, time);
|
|
if (result.status != ASTRO_SUCCESS)
|
|
return ApsisError(result.status);
|
|
dist = result.value;
|
|
if (i == 0)
|
|
{
|
|
max_dist = min_dist = dist;
|
|
}
|
|
else
|
|
{
|
|
if (dist > max_dist)
|
|
{
|
|
max_dist = dist;
|
|
t_max = time;
|
|
}
|
|
if (dist < min_dist)
|
|
{
|
|
min_dist = dist;
|
|
t_min = time;
|
|
}
|
|
}
|
|
}
|
|
|
|
t1 = Astronomy_AddDays(t_min, -2 * interval);
|
|
perihelion = PlanetExtreme(body, APSIS_PERICENTER, t1, 4 * interval);
|
|
|
|
t1 = Astronomy_AddDays(t_max, -2 * interval);
|
|
aphelion = PlanetExtreme(body, APSIS_APOCENTER, t1, 4 * interval);
|
|
|
|
if (perihelion.status == ASTRO_SUCCESS && perihelion.time.tt >= startTime.tt)
|
|
{
|
|
if (aphelion.status == ASTRO_SUCCESS && aphelion.time.tt >= startTime.tt)
|
|
{
|
|
/* Perihelion and aphelion are both valid. Pick the one that comes first. */
|
|
if (aphelion.time.tt < perihelion.time.tt)
|
|
return aphelion;
|
|
}
|
|
return perihelion;
|
|
}
|
|
|
|
if (aphelion.status == ASTRO_SUCCESS && aphelion.time.tt >= startTime.tt)
|
|
return aphelion;
|
|
|
|
return ApsisError(ASTRO_FAIL_APSIS);
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief
|
|
* Finds the date and time of a planet's perihelion (closest approach to the Sun)
|
|
* or aphelion (farthest distance from the Sun) after a given time.
|
|
*
|
|
* Given a date and time to start the search in `startTime`, this function finds the
|
|
* next date and time that the center of the specified planet reaches the closest or farthest point
|
|
* in its orbit with respect to the center of the Sun, whichever comes first
|
|
* after `startTime`.
|
|
*
|
|
* The closest point is called *perihelion* and the farthest point is called *aphelion*.
|
|
* The word *apsis* refers to either event.
|
|
*
|
|
* To iterate through consecutive alternating perihelion and aphelion events,
|
|
* call `Astronomy_SearchPlanetApsis` once, then use the return value to call
|
|
* #Astronomy_NextPlanetApsis. After that, keep feeding the previous return value
|
|
* from `Astronomy_NextPlanetApsis` into another call of `Astronomy_NextPlanetApsis`
|
|
* as many times as desired.
|
|
*
|
|
* @param body
|
|
* The planet for which to find the next perihelion/aphelion event.
|
|
* Not allowed to be `BODY_SUN` or `BODY_MOON`.
|
|
*
|
|
* @param startTime
|
|
* The date and time at which to start searching for the next perihelion or aphelion.
|
|
*
|
|
* @return
|
|
* If successful, the `status` field in the returned structure holds `ASTRO_SUCCESS`,
|
|
* `time` holds the date and time of the next planetary apsis, `kind` holds either
|
|
* `APSIS_PERICENTER` for perihelion or `APSIS_APOCENTER` for aphelion, and the distance
|
|
* values `dist_au` (astronomical units) and `dist_km` (kilometers) are valid.
|
|
* If the function fails, `status` holds some value other than `ASTRO_SUCCESS` that
|
|
* indicates what went wrong, and the other structure fields are invalid.
|
|
*/
|
|
astro_apsis_t Astronomy_SearchPlanetApsis(astro_body_t body, astro_time_t startTime)
|
|
{
|
|
astro_time_t t1, t2;
|
|
astro_search_result_t search;
|
|
astro_func_result_t m1, m2;
|
|
planet_distance_context_t context;
|
|
astro_apsis_t result;
|
|
int iter;
|
|
double orbit_period_days;
|
|
double increment; /* number of days to skip in each iteration */
|
|
astro_func_result_t dist;
|
|
|
|
if (body == BODY_NEPTUNE || body == BODY_PLUTO)
|
|
return BruteSearchPlanetApsis(body, startTime);
|
|
|
|
orbit_period_days = PlanetOrbitalPeriod(body);
|
|
if (orbit_period_days == 0.0)
|
|
return ApsisError(ASTRO_INVALID_BODY); /* The body must be a planet. */
|
|
|
|
increment = orbit_period_days / 6.0;
|
|
|
|
context.body = body;
|
|
|
|
t1 = startTime;
|
|
context.direction = +1;
|
|
m1 = planet_distance_slope(&context, t1);
|
|
if (m1.status != ASTRO_SUCCESS)
|
|
return ApsisError(m1.status);
|
|
|
|
for (iter=0; iter * increment < 2.0 * orbit_period_days; ++iter)
|
|
{
|
|
t2 = Astronomy_AddDays(t1, increment);
|
|
context.direction = +1;
|
|
m2 = planet_distance_slope(&context, t2);
|
|
if (m2.status != ASTRO_SUCCESS)
|
|
return ApsisError(m2.status);
|
|
|
|
if (m1.value * m2.value <= 0.0)
|
|
{
|
|
/* There is a change of slope polarity within the time range [t1, t2]. */
|
|
/* Therefore this time range contains an apsis. */
|
|
/* Figure out whether it is perihelion or aphelion. */
|
|
|
|
if (m1.value < 0.0 || m2.value > 0.0)
|
|
{
|
|
/* We found a minimum-distance event: perihelion. */
|
|
/* Search the time range for the time when the slope goes from negative to positive. */
|
|
context.direction = +1;
|
|
result.kind = APSIS_PERICENTER;
|
|
}
|
|
else if (m1.value > 0.0 || m2.value < 0.0)
|
|
{
|
|
/* We found a maximum-distance event: aphelion. */
|
|
/* Search the time range for the time when the slope goes from positive to negative. */
|
|
context.direction = -1;
|
|
result.kind = APSIS_APOCENTER;
|
|
}
|
|
else
|
|
{
|
|
/* This should never happen. It should not be possible for both slopes to be zero. */
|
|
return ApsisError(ASTRO_INTERNAL_ERROR);
|
|
}
|
|
|
|
search = Astronomy_Search(planet_distance_slope, &context, t1, t2, 1.0);
|
|
if (search.status != ASTRO_SUCCESS)
|
|
return ApsisError(search.status);
|
|
|
|
dist = Astronomy_HelioDistance(body, search.time);
|
|
if (dist.status != ASTRO_SUCCESS)
|
|
return ApsisError(dist.status);
|
|
|
|
result.status = ASTRO_SUCCESS;
|
|
result.time = search.time;
|
|
result.dist_au = dist.value;
|
|
result.dist_km = dist.value * KM_PER_AU;
|
|
return result;
|
|
}
|
|
|
|
/* We have not yet found a slope polarity change. Keep searching. */
|
|
t1 = t2;
|
|
m1 = m2;
|
|
}
|
|
|
|
/* It should not be possible to fail to find an apsis within 2 orbits. */
|
|
return ApsisError(ASTRO_INTERNAL_ERROR);
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Finds the next planetary perihelion or aphelion event in a series.
|
|
*
|
|
* This function requires an #astro_apsis_t value obtained from a call
|
|
* to #Astronomy_SearchPlanetApsis or `Astronomy_NextPlanetApsis`.
|
|
* Given an aphelion event, this function finds the next perihelion event, and vice versa.
|
|
*
|
|
* See #Astronomy_SearchPlanetApsis for more details.
|
|
*
|
|
* @param body
|
|
* The planet for which to find the next perihelion/aphelion event.
|
|
* Not allowed to be `BODY_SUN` or `BODY_MOON`.
|
|
* Must match the body passed into the call that produced the `apsis` parameter.
|
|
*
|
|
* @param apsis
|
|
* An apsis event obtained from a call to #Astronomy_SearchPlanetApsis or `Astronomy_NextPlanetApsis`.
|
|
*
|
|
* @return
|
|
* Same as the return value for #Astronomy_SearchPlanetApsis.
|
|
*/
|
|
astro_apsis_t Astronomy_NextPlanetApsis(astro_body_t body, astro_apsis_t apsis)
|
|
{
|
|
double skip; /* number of days to skip to start looking for next apsis event */
|
|
astro_apsis_t next;
|
|
astro_time_t time;
|
|
|
|
if (apsis.status != ASTRO_SUCCESS)
|
|
return ApsisError(ASTRO_INVALID_PARAMETER);
|
|
|
|
if (apsis.kind != APSIS_APOCENTER && apsis.kind != APSIS_PERICENTER)
|
|
return ApsisError(ASTRO_INVALID_PARAMETER);
|
|
|
|
skip = 0.25 * PlanetOrbitalPeriod(body); /* skip 1/4 of an orbit before starting search again */
|
|
if (skip <= 0.0)
|
|
return ApsisError(ASTRO_INVALID_BODY); /* body must be a planet */
|
|
|
|
time = Astronomy_AddDays(apsis.time, skip);
|
|
next = Astronomy_SearchPlanetApsis(body, time);
|
|
if (next.status == ASTRO_SUCCESS)
|
|
{
|
|
/* Verify that we found the opposite apsis from the previous one. */
|
|
if (next.kind + apsis.kind != 1)
|
|
return ApsisError(ASTRO_INTERNAL_ERROR);
|
|
}
|
|
return next;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Calculates the inverse of a rotation matrix.
|
|
*
|
|
* Given a rotation matrix that performs some coordinate transform,
|
|
* this function returns the matrix that reverses that trasnform.
|
|
*
|
|
* @param rotation
|
|
* The rotation matrix to be inverted.
|
|
*
|
|
* @return
|
|
* A rotation matrix that performs the opposite transformation.
|
|
*/
|
|
astro_rotation_t Astronomy_InverseRotation(astro_rotation_t rotation)
|
|
{
|
|
astro_rotation_t inverse;
|
|
|
|
if (rotation.status != ASTRO_SUCCESS)
|
|
return RotationErr(ASTRO_INVALID_PARAMETER);
|
|
|
|
inverse.status = ASTRO_SUCCESS;
|
|
inverse.rot[0][0] = rotation.rot[0][0];
|
|
inverse.rot[0][1] = rotation.rot[1][0];
|
|
inverse.rot[0][2] = rotation.rot[2][0];
|
|
inverse.rot[1][0] = rotation.rot[0][1];
|
|
inverse.rot[1][1] = rotation.rot[1][1];
|
|
inverse.rot[1][2] = rotation.rot[2][1];
|
|
inverse.rot[2][0] = rotation.rot[0][2];
|
|
inverse.rot[2][1] = rotation.rot[1][2];
|
|
inverse.rot[2][2] = rotation.rot[2][2];
|
|
|
|
return inverse;
|
|
}
|
|
|
|
/**
|
|
* @brief Creates a rotation based on applying one rotation followed by another.
|
|
*
|
|
* Given two rotation matrices, returns a combined rotation matrix that is
|
|
* equivalent to rotating based on the first matrix, followed by the second.
|
|
*
|
|
* @param a
|
|
* The first rotation to apply.
|
|
*
|
|
* @param b
|
|
* The second rotation to apply.
|
|
*
|
|
* @return
|
|
* The combined rotation matrix.
|
|
*/
|
|
astro_rotation_t Astronomy_CombineRotation(astro_rotation_t a, astro_rotation_t b)
|
|
{
|
|
astro_rotation_t c;
|
|
|
|
if (a.status != ASTRO_SUCCESS || b.status != ASTRO_SUCCESS)
|
|
return RotationErr(ASTRO_INVALID_PARAMETER);
|
|
|
|
/*
|
|
Use matrix multiplication: c = b*a.
|
|
We put 'b' on the left and 'a' on the right because,
|
|
just like when you use a matrix M to rotate a vector V,
|
|
you put the M on the left in the product M*V.
|
|
We can think of this as 'b' rotating all the 3 column vectors in 'a'.
|
|
*/
|
|
c.rot[0][0] = b.rot[0][0]*a.rot[0][0] + b.rot[1][0]*a.rot[0][1] + b.rot[2][0]*a.rot[0][2];
|
|
c.rot[1][0] = b.rot[0][0]*a.rot[1][0] + b.rot[1][0]*a.rot[1][1] + b.rot[2][0]*a.rot[1][2];
|
|
c.rot[2][0] = b.rot[0][0]*a.rot[2][0] + b.rot[1][0]*a.rot[2][1] + b.rot[2][0]*a.rot[2][2];
|
|
c.rot[0][1] = b.rot[0][1]*a.rot[0][0] + b.rot[1][1]*a.rot[0][1] + b.rot[2][1]*a.rot[0][2];
|
|
c.rot[1][1] = b.rot[0][1]*a.rot[1][0] + b.rot[1][1]*a.rot[1][1] + b.rot[2][1]*a.rot[1][2];
|
|
c.rot[2][1] = b.rot[0][1]*a.rot[2][0] + b.rot[1][1]*a.rot[2][1] + b.rot[2][1]*a.rot[2][2];
|
|
c.rot[0][2] = b.rot[0][2]*a.rot[0][0] + b.rot[1][2]*a.rot[0][1] + b.rot[2][2]*a.rot[0][2];
|
|
c.rot[1][2] = b.rot[0][2]*a.rot[1][0] + b.rot[1][2]*a.rot[1][1] + b.rot[2][2]*a.rot[1][2];
|
|
c.rot[2][2] = b.rot[0][2]*a.rot[2][0] + b.rot[1][2]*a.rot[2][1] + b.rot[2][2]*a.rot[2][2];
|
|
|
|
c.status = ASTRO_SUCCESS;
|
|
return c;
|
|
}
|
|
|
|
/**
|
|
* @brief Converts spherical coordinates to Cartesian coordinates.
|
|
*
|
|
* Given spherical coordinates and a time at which they are valid,
|
|
* returns a vector of Cartesian coordinates. The returned value
|
|
* includes the time, as required by the type #astro_vector_t.
|
|
*
|
|
* @param sphere
|
|
* Spherical coordinates to be converted.
|
|
*
|
|
* @param time
|
|
* The time that should be included in the return value.
|
|
*
|
|
* @return
|
|
* The vector form of the supplied spherical coordinates.
|
|
*/
|
|
astro_vector_t Astronomy_VectorFromSphere(astro_spherical_t sphere, astro_time_t time)
|
|
{
|
|
astro_vector_t vector;
|
|
double radlat, radlon, rcoslat;
|
|
|
|
if (sphere.status != ASTRO_SUCCESS)
|
|
return VecError(ASTRO_INVALID_PARAMETER, time);
|
|
|
|
radlat = sphere.lat * DEG2RAD;
|
|
radlon = sphere.lon * DEG2RAD;
|
|
rcoslat = sphere.dist * cos(radlat);
|
|
|
|
vector.status = ASTRO_SUCCESS;
|
|
vector.t = time;
|
|
vector.x = rcoslat * cos(radlon);
|
|
vector.y = rcoslat * sin(radlon);
|
|
vector.z = sphere.dist * sin(radlat);
|
|
|
|
return vector;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Converts Cartesian coordinates to spherical coordinates.
|
|
*
|
|
* Given a Cartesian vector, returns latitude, longitude, and distance.
|
|
*
|
|
* @param vector
|
|
* Cartesian vector to be converted to spherical coordinates.
|
|
*
|
|
* @return
|
|
* Spherical coordinates that are equivalent to the given vector.
|
|
*/
|
|
astro_spherical_t Astronomy_SphereFromVector(astro_vector_t vector)
|
|
{
|
|
double xyproj;
|
|
astro_spherical_t sphere;
|
|
|
|
xyproj = vector.x*vector.x + vector.y*vector.y;
|
|
sphere.dist = sqrt(xyproj + vector.z*vector.z);
|
|
if (xyproj == 0.0)
|
|
{
|
|
if (vector.z == 0.0)
|
|
{
|
|
/* Indeterminate coordinates; pos vector has zero length. */
|
|
return SphereError(ASTRO_INVALID_PARAMETER);
|
|
}
|
|
|
|
sphere.lon = 0.0;
|
|
sphere.lat = (vector.z < 0.0) ? -90.0 : +90.0;
|
|
}
|
|
else
|
|
{
|
|
sphere.lon = RAD2DEG * atan2(vector.y, vector.x);
|
|
if (sphere.lon < 0.0)
|
|
sphere.lon += 360.0;
|
|
|
|
sphere.lat = RAD2DEG * atan2(vector.z, sqrt(xyproj));
|
|
}
|
|
|
|
sphere.status = ASTRO_SUCCESS;
|
|
return sphere;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief
|
|
* Given angular equatorial coordinates in `equ`, calculates equatorial vector.
|
|
*
|
|
* @param equ
|
|
* Angular equatorial coordinates to be converted to a vector.
|
|
*
|
|
* @param time
|
|
* The date and time of the observation. This is needed because the returned
|
|
* vector requires a valid time value when passed to certain other functions.
|
|
*
|
|
* @return
|
|
* A vector in the equatorial system.
|
|
*/
|
|
astro_vector_t Astronomy_VectorFromEquator(astro_equatorial_t equ, astro_time_t time)
|
|
{
|
|
astro_spherical_t sphere;
|
|
|
|
if (equ.status != ASTRO_SUCCESS)
|
|
return VecError(ASTRO_INVALID_PARAMETER, time);
|
|
|
|
sphere.status = ASTRO_SUCCESS;
|
|
sphere.lat = equ.dec;
|
|
sphere.lon = 15.0 * equ.ra; /* convert sidereal hours to degrees */
|
|
sphere.dist = equ.dist;
|
|
|
|
return Astronomy_VectorFromSphere(sphere, time);
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief
|
|
* Given an equatorial vector, calculates equatorial angular coordinates.
|
|
*
|
|
* @param vector
|
|
* A vector in an equatorial coordinate system.
|
|
*
|
|
* @return
|
|
* Angular coordinates expressed in the same equatorial system as `vector`.
|
|
*/
|
|
astro_equatorial_t Astronomy_EquatorFromVector(astro_vector_t vector)
|
|
{
|
|
astro_equatorial_t equ;
|
|
astro_spherical_t sphere;
|
|
|
|
sphere = Astronomy_SphereFromVector(vector);
|
|
if (sphere.status != ASTRO_SUCCESS)
|
|
return EquError(sphere.status);
|
|
|
|
equ.status = ASTRO_SUCCESS;
|
|
equ.dec = sphere.lat;
|
|
equ.ra = sphere.lon / 15.0; /* convert degrees to sidereal hours */
|
|
equ.dist = sphere.dist;
|
|
|
|
return equ;
|
|
}
|
|
|
|
|
|
static double ToggleAzimuthDirection(double az)
|
|
{
|
|
az = 360.0 - az;
|
|
if (az >= 360.0)
|
|
az -= 360.0;
|
|
else if (az < 0.0)
|
|
az += 360.0;
|
|
return az;
|
|
}
|
|
|
|
/**
|
|
* @brief Converts Cartesian coordinates to horizontal coordinates.
|
|
*
|
|
* Given a horizontal Cartesian vector, returns horizontal azimuth and altitude.
|
|
*
|
|
* *IMPORTANT:* This function differs from #Astronomy_SphereFromVector in two ways:
|
|
* - `Astronomy_SphereFromVector` returns a `lon` value that represents azimuth defined counterclockwise
|
|
* from north (e.g., west = +90), but this function represents a clockwise rotation
|
|
* (e.g., east = +90). The difference is because `Astronomy_SphereFromVector` is intended
|
|
* to preserve the vector "right-hand rule", while this function defines azimuth in a more
|
|
* traditional way as used in navigation and cartography.
|
|
* - This function optionally corrects for atmospheric refraction, while `Astronomy_SphereFromVector`
|
|
* does not.
|
|
*
|
|
* The returned structure contains the azimuth in `lon`.
|
|
* It is measured in degrees clockwise from north: east = +90 degrees, west = +270 degrees.
|
|
*
|
|
* The altitude is stored in `lat`.
|
|
*
|
|
* The distance to the observed object is stored in `dist`,
|
|
* and is expressed in astronomical units (AU).
|
|
*
|
|
* @param vector
|
|
* Cartesian vector to be converted to horizontal coordinates.
|
|
*
|
|
* @param refraction
|
|
* `REFRACTION_NORMAL`: correct altitude for atmospheric refraction (recommended).
|
|
* `REFRACTION_NONE`: no atmospheric refraction correction is performed.
|
|
* `REFRACTION_JPLHOR`: for JPL Horizons compatibility testing only; not recommended for normal use.
|
|
*
|
|
* @return
|
|
* If successful, `status` holds `ASTRO_SUCCESS` and the other fields are valid as described
|
|
* in the function remarks.
|
|
* Otherwise `status` holds an error code and the other fields are undefined.
|
|
*/
|
|
astro_spherical_t Astronomy_HorizonFromVector(astro_vector_t vector, astro_refraction_t refraction)
|
|
{
|
|
astro_spherical_t sphere;
|
|
|
|
sphere = Astronomy_SphereFromVector(vector);
|
|
if (sphere.status == ASTRO_SUCCESS)
|
|
{
|
|
/* Convert azimuth from counterclockwise-from-north to clockwise-from-north. */
|
|
sphere.lon = ToggleAzimuthDirection(sphere.lon);
|
|
sphere.lat += Astronomy_Refraction(refraction, sphere.lat);
|
|
}
|
|
|
|
return sphere;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief
|
|
* Given apparent angular horizontal coordinates in `sphere`, calculate horizontal vector.
|
|
*
|
|
* @param sphere
|
|
* A structure that contains apparent horizontal coordinates:
|
|
* `lat` holds the refracted azimuth angle,
|
|
* `lon` holds the azimuth in degrees clockwise from north,
|
|
* and `dist` holds the distance from the observer to the object in AU.
|
|
*
|
|
* @param time
|
|
* The date and time of the observation. This is needed because the returned
|
|
* #astro_vector_t structure requires a valid time value when passed to certain other functions.
|
|
*
|
|
* @param refraction
|
|
* The refraction option used to model atmospheric lensing. See #Astronomy_Refraction.
|
|
* This specifies how refraction is to be removed from the altitude stored in `sphere.lat`.
|
|
*
|
|
* @return
|
|
* A vector in the horizontal system: `x` = north, `y` = west, and `z` = zenith (up).
|
|
*/
|
|
astro_vector_t Astronomy_VectorFromHorizon(astro_spherical_t sphere, astro_time_t time, astro_refraction_t refraction)
|
|
{
|
|
if (sphere.status != ASTRO_SUCCESS)
|
|
return VecError(ASTRO_INVALID_PARAMETER, time);
|
|
|
|
/* Convert azimuth from clockwise-from-north to counterclockwise-from-north. */
|
|
sphere.lon = ToggleAzimuthDirection(sphere.lon);
|
|
|
|
/* Reverse any applied refraction. */
|
|
sphere.lat += Astronomy_InverseRefraction(refraction, sphere.lat);
|
|
|
|
return Astronomy_VectorFromSphere(sphere, time);
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief
|
|
* Calculates the amount of "lift" to an altitude angle caused by atmospheric refraction.
|
|
*
|
|
* Given an altitude angle and a refraction option, calculates
|
|
* the amount of "lift" caused by atmospheric refraction.
|
|
* This is the number of degrees higher in the sky an object appears
|
|
* due to the lensing of the Earth's atmosphere.
|
|
*
|
|
* @param refraction
|
|
* The option selecting which refraction correction to use.
|
|
* If `REFRACTION_NORMAL`, uses a well-behaved refraction model that works well for
|
|
* all valid values (-90 to +90) of `altitude`.
|
|
* If `REFRACTION_JPLHOR`, this function returns a compatible value with the JPL Horizons tool.
|
|
* If any other value (including `REFRACTION_NONE`), this function returns 0.
|
|
*
|
|
* @param altitude
|
|
* An altitude angle in a horizontal coordinate system. Must be a value between -90 and +90.
|
|
*
|
|
* @return
|
|
* The angular adjustment in degrees to be added to the altitude angle to correct for atmospheric lensing.
|
|
*/
|
|
double Astronomy_Refraction(astro_refraction_t refraction, double altitude)
|
|
{
|
|
double refr, hd;
|
|
|
|
if (altitude < -90.0 || altitude > +90.0)
|
|
return 0.0; /* no attempt to correct an invalid altitude */
|
|
|
|
if (refraction == REFRACTION_NORMAL || refraction == REFRACTION_JPLHOR)
|
|
{
|
|
// http://extras.springer.com/1999/978-1-4471-0555-8/chap4/horizons/horizons.pdf
|
|
// JPL Horizons says it uses refraction algorithm from
|
|
// Meeus "Astronomical Algorithms", 1991, p. 101-102.
|
|
// I found the following Go implementation:
|
|
// https://github.com/soniakeys/meeus/blob/master/v3/refraction/refract.go
|
|
// This is a translation from the function "Saemundsson" there.
|
|
// I found experimentally that JPL Horizons clamps the angle to 1 degree below the horizon.
|
|
// This is important because the 'refr' formula below goes crazy near hd = -5.11.
|
|
hd = altitude;
|
|
if (hd < -1.0)
|
|
hd = -1.0;
|
|
|
|
refr = (1.02 / tan((hd+10.3/(hd+5.11))*DEG2RAD)) / 60.0;
|
|
|
|
if (refraction == REFRACTION_NORMAL && altitude < -1.0)
|
|
{
|
|
// In "normal" mode we gradually reduce refraction toward the nadir
|
|
// so that we never get an altitude angle less than -90 degrees.
|
|
// When horizon angle is -1 degrees, the factor is exactly 1.
|
|
// As altitude approaches -90 (the nadir), the fraction approaches 0 linearly.
|
|
refr *= (altitude + 90.0) / 89.0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* No refraction, or the refraction option is invalid. */
|
|
refr = 0.0;
|
|
}
|
|
|
|
return refr;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief
|
|
* Calculates the inverse of an atmospheric refraction angle.
|
|
*
|
|
* Given an observed altitude angle that includes atmospheric refraction,
|
|
* calculate the negative angular correction to obtain the unrefracted
|
|
* altitude. This is useful for cases where observed horizontal
|
|
* coordinates are to be converted to another orientation system,
|
|
* but refraction first must be removed from the observed position.
|
|
*
|
|
* @param refraction
|
|
* The option selecting which refraction correction to use.
|
|
* See #Astronomy_Refraction.
|
|
*
|
|
* @param bent_altitude
|
|
* The apparent altitude that includes atmospheric refraction.
|
|
*
|
|
* @return
|
|
* The angular adjustment in degrees to be added to the
|
|
* altitude angle to correct for atmospheric lensing.
|
|
* This will be less than or equal to zero.
|
|
*/
|
|
double Astronomy_InverseRefraction(astro_refraction_t refraction, double bent_altitude)
|
|
{
|
|
double altitude, diff;
|
|
|
|
if (bent_altitude < -90.0 || bent_altitude > +90.0)
|
|
return 0.0; /* no attempt to correct an invalid altitude */
|
|
|
|
/* Find the pre-adjusted altitude whose refraction correction leads to 'altitude'. */
|
|
altitude = bent_altitude - Astronomy_Refraction(refraction, bent_altitude);
|
|
for(;;)
|
|
{
|
|
/* See how close we got. */
|
|
diff = (altitude + Astronomy_Refraction(refraction, altitude)) - bent_altitude;
|
|
if (fabs(diff) < 1.0e-14)
|
|
return altitude - bent_altitude;
|
|
|
|
altitude -= diff;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Applies a rotation to a vector, yielding a rotated vector.
|
|
*
|
|
* This function transforms a vector in one orientation to a vector
|
|
* in another orientation.
|
|
*
|
|
* @param rotation
|
|
* A rotation matrix that specifies how the orientation of the vector is to be changed.
|
|
*
|
|
* @param vector
|
|
* The vector whose orientation is to be changed.
|
|
*
|
|
* @return
|
|
* A vector in the orientation specified by `rotation`.
|
|
*/
|
|
astro_vector_t Astronomy_RotateVector(astro_rotation_t rotation, astro_vector_t vector)
|
|
{
|
|
astro_vector_t target;
|
|
|
|
if (rotation.status != ASTRO_SUCCESS || vector.status != ASTRO_SUCCESS)
|
|
return VecError(ASTRO_INVALID_PARAMETER, vector.t);
|
|
|
|
target.status = ASTRO_SUCCESS;
|
|
target.t = vector.t;
|
|
target.x = rotation.rot[0][0]*vector.x + rotation.rot[1][0]*vector.y + rotation.rot[2][0]*vector.z;
|
|
target.y = rotation.rot[0][1]*vector.x + rotation.rot[1][1]*vector.y + rotation.rot[2][1]*vector.z;
|
|
target.z = rotation.rot[0][2]*vector.x + rotation.rot[1][2]*vector.y + rotation.rot[2][2]*vector.z;
|
|
|
|
return target;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief
|
|
* Calculates a rotation matrix from equatorial J2000 (EQJ) to ecliptic J2000 (ECL).
|
|
*
|
|
* This is one of the family of functions that returns a rotation matrix
|
|
* for converting from one orientation to another.
|
|
* Source: EQJ = equatorial system, using equator at J2000 epoch.
|
|
* Target: ECL = ecliptic system, using equator at J2000 epoch.
|
|
*
|
|
* @return
|
|
* A rotation matrix that converts EQJ to ECL.
|
|
*/
|
|
astro_rotation_t Astronomy_Rotation_EQJ_ECL(void)
|
|
{
|
|
/* ob = mean obliquity of the J2000 ecliptic = 0.40909260059599012 radians. */
|
|
static const double c = 0.9174821430670688; /* cos(ob) */
|
|
static const double s = 0.3977769691083922; /* sin(ob) */
|
|
astro_rotation_t r;
|
|
|
|
r.status = ASTRO_SUCCESS;
|
|
r.rot[0][0] = 1.0; r.rot[1][0] = 0.0; r.rot[2][0] = 0.0;
|
|
r.rot[0][1] = 0.0; r.rot[1][1] = +c; r.rot[2][1] = +s;
|
|
r.rot[0][2] = 0.0; r.rot[1][2] = -s; r.rot[2][2] = +c;
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Calculates a rotation matrix from ecliptic J2000 (ECL) to equatorial J2000 (EQJ).
|
|
*
|
|
* This is one of the family of functions that returns a rotation matrix
|
|
* for converting from one orientation to another.
|
|
* Source: ECL = ecliptic system, using equator at J2000 epoch.
|
|
* Target: EQJ = equatorial system, using equator at J2000 epoch.
|
|
*
|
|
* @return
|
|
* A rotation matrix that converts ECL to EQJ.
|
|
*/
|
|
astro_rotation_t Astronomy_Rotation_ECL_EQJ(void)
|
|
{
|
|
/* ob = mean obliquity of the J2000 ecliptic = 0.40909260059599012 radians. */
|
|
static const double c = 0.9174821430670688; /* cos(ob) */
|
|
static const double s = 0.3977769691083922; /* sin(ob) */
|
|
astro_rotation_t r;
|
|
|
|
r.status = ASTRO_SUCCESS;
|
|
r.rot[0][0] = 1.0; r.rot[1][0] = 0.0; r.rot[2][0] = 0.0;
|
|
r.rot[0][1] = 0.0; r.rot[1][1] = +c; r.rot[2][1] = -s;
|
|
r.rot[0][2] = 0.0; r.rot[1][2] = +s; r.rot[2][2] = +c;
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Calculates a rotation matrix from equatorial J2000 (EQJ) to equatorial of-date (EQD).
|
|
*
|
|
* This is one of the family of functions that returns a rotation matrix
|
|
* for converting from one orientation to another.
|
|
* Source: EQJ = equatorial system, using equator at J2000 epoch.
|
|
* Target: EQD = equatorial system, using equator of the specified date/time.
|
|
*
|
|
* @param time
|
|
* The date and time at which the Earth's equator defines the target orientation.
|
|
*
|
|
* @return
|
|
* A rotation matrix that converts EQJ to EQD at `time`.
|
|
*/
|
|
astro_rotation_t Astronomy_Rotation_EQJ_EQD(astro_time_t time)
|
|
{
|
|
astro_rotation_t prec, nut;
|
|
|
|
prec = precession_rot(0.0, time.tt);
|
|
nut = nutation_rot(&time, 0);
|
|
return Astronomy_CombineRotation(prec, nut);
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Calculates a rotation matrix from equatorial of-date (EQD) to equatorial J2000 (EQJ).
|
|
*
|
|
* This is one of the family of functions that returns a rotation matrix
|
|
* for converting from one orientation to another.
|
|
* Source: EQD = equatorial system, using equator of the specified date/time.
|
|
* Target: EQJ = equatorial system, using equator at J2000 epoch.
|
|
*
|
|
* @param time
|
|
* The date and time at which the Earth's equator defines the source orientation.
|
|
*
|
|
* @return
|
|
* A rotation matrix that converts EQD at `time` to EQJ.
|
|
*/
|
|
astro_rotation_t Astronomy_Rotation_EQD_EQJ(astro_time_t time)
|
|
{
|
|
astro_rotation_t prec, nut;
|
|
|
|
nut = nutation_rot(&time, 1);
|
|
prec = precession_rot(time.tt, 0.0);
|
|
return Astronomy_CombineRotation(nut, prec);
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief
|
|
* Calculates a rotation matrix from equatorial of-date (EQD) to horizontal (HOR).
|
|
*
|
|
* This is one of the family of functions that returns a rotation matrix
|
|
* for converting from one orientation to another.
|
|
* Source: EQD = equatorial system, using equator of the specified date/time.
|
|
* Target: HOR = horizontal system.
|
|
*
|
|
* @param time
|
|
* The date and time at which the Earth's equator applies.
|
|
*
|
|
* @param observer
|
|
* A location near the Earth's mean sea level that defines the observer's horizon.
|
|
*
|
|
* @return
|
|
* A rotation matrix that converts EQD to HOR at `time` and for `observer`.
|
|
* The components of the horizontal vector are:
|
|
* x = north, y = west, z = zenith (straight up from the observer).
|
|
* These components are chosen so that the "right-hand rule" works for the vector
|
|
* and so that north represents the direction where azimuth = 0.
|
|
*/
|
|
astro_rotation_t Astronomy_Rotation_EQD_HOR(astro_time_t time, astro_observer_t observer)
|
|
{
|
|
astro_rotation_t rot;
|
|
double uze[3], une[3], uwe[3];
|
|
double uz[3], un[3], uw[3];
|
|
double spin_angle;
|
|
|
|
double sinlat = sin(observer.latitude * DEG2RAD);
|
|
double coslat = cos(observer.latitude * DEG2RAD);
|
|
double sinlon = sin(observer.longitude * DEG2RAD);
|
|
double coslon = cos(observer.longitude * DEG2RAD);
|
|
|
|
uze[0] = coslat * coslon;
|
|
uze[1] = coslat * sinlon;
|
|
uze[2] = sinlat;
|
|
|
|
une[0] = -sinlat * coslon;
|
|
une[1] = -sinlat * sinlon;
|
|
une[2] = coslat;
|
|
|
|
uwe[0] = sinlon;
|
|
uwe[1] = -coslon;
|
|
uwe[2] = 0.0;
|
|
|
|
spin_angle = -15.0 * sidereal_time(&time);
|
|
spin(spin_angle, uze, uz);
|
|
spin(spin_angle, une, un);
|
|
spin(spin_angle, uwe, uw);
|
|
|
|
rot.rot[0][0] = un[0]; rot.rot[1][0] = un[1]; rot.rot[2][0] = un[2];
|
|
rot.rot[0][1] = uw[0]; rot.rot[1][1] = uw[1]; rot.rot[2][1] = uw[2];
|
|
rot.rot[0][2] = uz[0]; rot.rot[1][2] = uz[1]; rot.rot[2][2] = uz[2];
|
|
|
|
rot.status = ASTRO_SUCCESS;
|
|
return rot;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief
|
|
* Calculates a rotation matrix from horizontal (HOR) to equatorial of-date (EQD).
|
|
*
|
|
* This is one of the family of functions that returns a rotation matrix
|
|
* for converting from one orientation to another.
|
|
* Source: HOR = horizontal system (x=North, y=West, z=Zenith).
|
|
* Target: EQD = equatorial system, using equator of the specified date/time.
|
|
*
|
|
* @param time
|
|
* The date and time at which the Earth's equator applies.
|
|
*
|
|
* @param observer
|
|
* A location near the Earth's mean sea level that defines the observer's horizon.
|
|
*
|
|
* @return
|
|
* A rotation matrix that converts HOR to EQD at `time` and for `observer`.
|
|
*/
|
|
astro_rotation_t Astronomy_Rotation_HOR_EQD(astro_time_t time, astro_observer_t observer)
|
|
{
|
|
astro_rotation_t rot = Astronomy_Rotation_EQD_HOR(time, observer);
|
|
return Astronomy_InverseRotation(rot);
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief
|
|
* Calculates a rotation matrix from horizontal (HOR) to J2000 equatorial (EQJ).
|
|
*
|
|
* This is one of the family of functions that returns a rotation matrix
|
|
* for converting from one orientation to another.
|
|
* Source: HOR = horizontal system (x=North, y=West, z=Zenith).
|
|
* Target: EQJ = equatorial system, using equator at the J2000 epoch.
|
|
*
|
|
* @param time
|
|
* The date and time of the observation.
|
|
*
|
|
* @param observer
|
|
* A location near the Earth's mean sea level that defines the observer's horizon.
|
|
*
|
|
* @return
|
|
* A rotation matrix that converts HOR to EQD at `time` and for `observer`.
|
|
*/
|
|
astro_rotation_t Astronomy_Rotation_HOR_EQJ(astro_time_t time, astro_observer_t observer)
|
|
{
|
|
astro_rotation_t hor_eqd, eqd_eqj;
|
|
|
|
hor_eqd = Astronomy_Rotation_HOR_EQD(time, observer);
|
|
eqd_eqj = Astronomy_Rotation_EQD_EQJ(time);
|
|
return Astronomy_CombineRotation(hor_eqd, eqd_eqj);
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief
|
|
* Calculates a rotation matrix from equatorial J2000 (EQJ) to horizontal (HOR).
|
|
*
|
|
* This is one of the family of functions that returns a rotation matrix
|
|
* for converting from one orientation to another.
|
|
* Source: EQJ = equatorial system, using the equator at the J2000 epoch.
|
|
* Target: HOR = horizontal system.
|
|
*
|
|
* @param time
|
|
* The date and time of the desired horizontal orientation.
|
|
*
|
|
* @param observer
|
|
* A location near the Earth's mean sea level that defines the observer's horizon.
|
|
*
|
|
* @return
|
|
* A rotation matrix that converts EQJ to HOR at `time` and for `observer`.
|
|
* The components of the horizontal vector are:
|
|
* x = north, y = west, z = zenith (straight up from the observer).
|
|
* These components are chosen so that the "right-hand rule" works for the vector
|
|
* and so that north represents the direction where azimuth = 0.
|
|
*/
|
|
astro_rotation_t Astronomy_Rotation_EQJ_HOR(astro_time_t time, astro_observer_t observer)
|
|
{
|
|
astro_rotation_t rot = Astronomy_Rotation_HOR_EQJ(time, observer);
|
|
return Astronomy_InverseRotation(rot);
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief
|
|
* Calculates a rotation matrix from equatorial of-date (EQD) to ecliptic J2000 (ECL).
|
|
*
|
|
* This is one of the family of functions that returns a rotation matrix
|
|
* for converting from one orientation to another.
|
|
* Source: EQD = equatorial system, using equator of date.
|
|
* Target: ECL = ecliptic system, using equator at J2000 epoch.
|
|
*
|
|
* @param time
|
|
* The date and time of the source equator.
|
|
*
|
|
* @return
|
|
* A rotation matrix that converts EQD to ECL.
|
|
*/
|
|
astro_rotation_t Astronomy_Rotation_EQD_ECL(astro_time_t time)
|
|
{
|
|
astro_rotation_t eqd_eqj;
|
|
astro_rotation_t eqj_ecl;
|
|
|
|
eqd_eqj = Astronomy_Rotation_EQD_EQJ(time);
|
|
eqj_ecl = Astronomy_Rotation_EQJ_ECL();
|
|
return Astronomy_CombineRotation(eqd_eqj, eqj_ecl);
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief
|
|
* Calculates a rotation matrix from ecliptic J2000 (ECL) to equatorial of-date (EQD).
|
|
*
|
|
* This is one of the family of functions that returns a rotation matrix
|
|
* for converting from one orientation to another.
|
|
* Source: ECL = ecliptic system, using equator at J2000 epoch.
|
|
* Target: EQD = equatorial system, using equator of date.
|
|
*
|
|
* @param time
|
|
* The date and time of the desired equator.
|
|
*
|
|
* @return
|
|
* A rotation matrix that converts ECL to EQD.
|
|
*/
|
|
astro_rotation_t Astronomy_Rotation_ECL_EQD(astro_time_t time)
|
|
{
|
|
astro_rotation_t rot = Astronomy_Rotation_EQD_ECL(time);
|
|
return Astronomy_InverseRotation(rot);
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Calculates a rotation matrix from ecliptic J2000 (ECL) to horizontal (HOR).
|
|
*
|
|
* This is one of the family of functions that returns a rotation matrix
|
|
* for converting from one orientation to another.
|
|
* Source: ECL = ecliptic system, using equator at J2000 epoch.
|
|
* Target: HOR = horizontal system.
|
|
*
|
|
* @param time
|
|
* The date and time of the desired horizontal orientation.
|
|
*
|
|
* @param observer
|
|
* A location near the Earth's mean sea level that defines the observer's horizon.
|
|
*
|
|
* @return
|
|
* A rotation matrix that converts ECL to HOR at `time` and for `observer`.
|
|
* The components of the horizontal vector are:
|
|
* x = north, y = west, z = zenith (straight up from the observer).
|
|
* These components are chosen so that the "right-hand rule" works for the vector
|
|
* and so that north represents the direction where azimuth = 0.
|
|
*/
|
|
astro_rotation_t Astronomy_Rotation_ECL_HOR(astro_time_t time, astro_observer_t observer)
|
|
{
|
|
astro_rotation_t ecl_eqd = Astronomy_Rotation_ECL_EQD(time);
|
|
astro_rotation_t eqd_hor = Astronomy_Rotation_EQD_HOR(time, observer);
|
|
return Astronomy_CombineRotation(ecl_eqd, eqd_hor);
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
* Calculates a rotation matrix from horizontal (HOR) to ecliptic J2000 (ECL).
|
|
*
|
|
* This is one of the family of functions that returns a rotation matrix
|
|
* for converting from one orientation to another.
|
|
* Source: HOR = horizontal system.
|
|
* Target: ECL = ecliptic system, using equator at J2000 epoch.
|
|
*
|
|
* @param time
|
|
* The date and time of the horizontal observation.
|
|
*
|
|
* @param observer
|
|
* The location of the horizontal observer.
|
|
*
|
|
* @return
|
|
* A rotation matrix that converts HOR to ECL.
|
|
*/
|
|
astro_rotation_t Astronomy_Rotation_HOR_ECL(astro_time_t time, astro_observer_t observer)
|
|
{
|
|
astro_rotation_t rot = Astronomy_Rotation_ECL_HOR(time, observer);
|
|
return Astronomy_InverseRotation(rot);
|
|
}
|
|
|
|
|
|
/** @cond DOXYGEN_SKIP */
|
|
typedef struct
|
|
{
|
|
const char *symbol;
|
|
const char *name;
|
|
}
|
|
constel_info_t;
|
|
|
|
|
|
typedef struct
|
|
{
|
|
int index;
|
|
double ra_lo;
|
|
double ra_hi;
|
|
double dec_lo;
|
|
}
|
|
constel_boundary_t;
|
|
/** @endcond */
|
|
|
|
#define NUM_CONSTELLATIONS 88
|
|
|
|
static const constel_info_t ConstelInfo[] = {
|
|
/* 0 */ { "And", "Andromeda" }
|
|
, /* 1 */ { "Ant", "Antila" }
|
|
, /* 2 */ { "Aps", "Apus" }
|
|
, /* 3 */ { "Aql", "Aquila" }
|
|
, /* 4 */ { "Aqr", "Aquarius" }
|
|
, /* 5 */ { "Ara", "Ara" }
|
|
, /* 6 */ { "Ari", "Aries" }
|
|
, /* 7 */ { "Aur", "Auriga" }
|
|
, /* 8 */ { "Boo", "Bootes" }
|
|
, /* 9 */ { "Cae", "Caelum" }
|
|
, /* 10 */ { "Cam", "Camelopardis" }
|
|
, /* 11 */ { "Cap", "Capricornus" }
|
|
, /* 12 */ { "Car", "Carina" }
|
|
, /* 13 */ { "Cas", "Cassiopeia" }
|
|
, /* 14 */ { "Cen", "Centaurus" }
|
|
, /* 15 */ { "Cep", "Cepheus" }
|
|
, /* 16 */ { "Cet", "Cetus" }
|
|
, /* 17 */ { "Cha", "Chamaeleon" }
|
|
, /* 18 */ { "Cir", "Circinus" }
|
|
, /* 19 */ { "CMa", "Canis Major" }
|
|
, /* 20 */ { "CMi", "Canis Minor" }
|
|
, /* 21 */ { "Cnc", "Cancer" }
|
|
, /* 22 */ { "Col", "Columba" }
|
|
, /* 23 */ { "Com", "Coma Berenices" }
|
|
, /* 24 */ { "CrA", "Corona Australis" }
|
|
, /* 25 */ { "CrB", "Corona Borealis" }
|
|
, /* 26 */ { "Crt", "Crater" }
|
|
, /* 27 */ { "Cru", "Crux" }
|
|
, /* 28 */ { "Crv", "Corvus" }
|
|
, /* 29 */ { "CVn", "Canes Venatici" }
|
|
, /* 30 */ { "Cyg", "Cygnus" }
|
|
, /* 31 */ { "Del", "Delphinus" }
|
|
, /* 32 */ { "Dor", "Dorado" }
|
|
, /* 33 */ { "Dra", "Draco" }
|
|
, /* 34 */ { "Equ", "Equuleus" }
|
|
, /* 35 */ { "Eri", "Eridanus" }
|
|
, /* 36 */ { "For", "Fornax" }
|
|
, /* 37 */ { "Gem", "Gemini" }
|
|
, /* 38 */ { "Gru", "Grus" }
|
|
, /* 39 */ { "Her", "Hercules" }
|
|
, /* 40 */ { "Hor", "Horologium" }
|
|
, /* 41 */ { "Hya", "Hydra" }
|
|
, /* 42 */ { "Hyi", "Hydrus" }
|
|
, /* 43 */ { "Ind", "Indus" }
|
|
, /* 44 */ { "Lac", "Lacerta" }
|
|
, /* 45 */ { "Leo", "Leo" }
|
|
, /* 46 */ { "Lep", "Lepus" }
|
|
, /* 47 */ { "Lib", "Libra" }
|
|
, /* 48 */ { "LMi", "Leo Minor" }
|
|
, /* 49 */ { "Lup", "Lupus" }
|
|
, /* 50 */ { "Lyn", "Lynx" }
|
|
, /* 51 */ { "Lyr", "Lyra" }
|
|
, /* 52 */ { "Men", "Mensa" }
|
|
, /* 53 */ { "Mic", "Microscopium" }
|
|
, /* 54 */ { "Mon", "Monoceros" }
|
|
, /* 55 */ { "Mus", "Musca" }
|
|
, /* 56 */ { "Nor", "Norma" }
|
|
, /* 57 */ { "Oct", "Octans" }
|
|
, /* 58 */ { "Oph", "Ophiuchus" }
|
|
, /* 59 */ { "Ori", "Orion" }
|
|
, /* 60 */ { "Pav", "Pavo" }
|
|
, /* 61 */ { "Peg", "Pegasus" }
|
|
, /* 62 */ { "Per", "Perseus" }
|
|
, /* 63 */ { "Phe", "Phoenix" }
|
|
, /* 64 */ { "Pic", "Pictor" }
|
|
, /* 65 */ { "PsA", "Pisces Austrinus" }
|
|
, /* 66 */ { "Psc", "Pisces" }
|
|
, /* 67 */ { "Pup", "Puppis" }
|
|
, /* 68 */ { "Pyx", "Pyxis" }
|
|
, /* 69 */ { "Ret", "Reticulum" }
|
|
, /* 70 */ { "Scl", "Sculptor" }
|
|
, /* 71 */ { "Sco", "Scorpius" }
|
|
, /* 72 */ { "Sct", "Scutum" }
|
|
, /* 73 */ { "Ser", "Serpens" }
|
|
, /* 74 */ { "Sex", "Sextans" }
|
|
, /* 75 */ { "Sge", "Sagitta" }
|
|
, /* 76 */ { "Sgr", "Sagittarius" }
|
|
, /* 77 */ { "Tau", "Taurus" }
|
|
, /* 78 */ { "Tel", "Telescopium" }
|
|
, /* 79 */ { "TrA", "Triangulum Australe" }
|
|
, /* 80 */ { "Tri", "Triangulum" }
|
|
, /* 81 */ { "Tuc", "Tucana" }
|
|
, /* 82 */ { "UMa", "Ursa Major" }
|
|
, /* 83 */ { "UMi", "Ursa Minor" }
|
|
, /* 84 */ { "Vel", "Vela" }
|
|
, /* 85 */ { "Vir", "Virgo" }
|
|
, /* 86 */ { "Vol", "Volans" }
|
|
, /* 87 */ { "Vul", "Vulpecula" }
|
|
};
|
|
|
|
static const constel_boundary_t ConstelBounds[] = {
|
|
{ 83, 0.00000000000000, 24.00000000000000, 88.00000000000000 } /* UMi */
|
|
, { 83, 8.00000000000000, 14.50000000000000, 86.50000000000000 } /* UMi */
|
|
, { 83, 21.00000000000000, 23.00000000000000, 86.16666666666667 } /* UMi */
|
|
, { 83, 18.00000000000000, 21.00000000000000, 86.00000000000000 } /* UMi */
|
|
, { 15, 0.00000000000000, 8.00000000000000, 85.00000000000000 } /* Cep */
|
|
, { 10, 9.16666666666667, 10.66666666666667, 82.00000000000000 } /* Cam */
|
|
, { 15, 0.00000000000000, 5.00000000000000, 80.00000000000000 } /* Cep */
|
|
, { 10, 10.66666666666667, 14.50000000000000, 80.00000000000000 } /* Cam */
|
|
, { 83, 17.50000000000000, 18.00000000000000, 80.00000000000000 } /* UMi */
|
|
, { 33, 20.16666666666667, 21.00000000000000, 80.00000000000000 } /* Dra */
|
|
, { 15, 0.00000000000000, 3.50833333333333, 77.00000000000000 } /* Cep */
|
|
, { 10, 11.50000000000000, 13.58333333333333, 77.00000000000000 } /* Cam */
|
|
, { 83, 16.53333333333333, 17.50000000000000, 75.00000000000000 } /* UMi */
|
|
, { 15, 20.16666666666667, 20.66666666666667, 75.00000000000000 } /* Cep */
|
|
, { 10, 7.96666666666667, 9.16666666666667, 73.50000000000000 } /* Cam */
|
|
, { 33, 9.16666666666667, 11.33333333333333, 73.50000000000000 } /* Dra */
|
|
, { 83, 13.00000000000000, 16.53333333333333, 70.00000000000000 } /* UMi */
|
|
, { 13, 3.10000000000000, 3.41666666666667, 68.00000000000000 } /* Cas */
|
|
, { 33, 20.41666666666667, 20.66666666666667, 67.00000000000000 } /* Dra */
|
|
, { 33, 11.33333333333333, 12.00000000000000, 66.50000000000000 } /* Dra */
|
|
, { 15, 0.00000000000000, 0.33333333333333, 66.00000000000000 } /* Cep */
|
|
, { 83, 14.00000000000000, 15.66666666666667, 66.00000000000000 } /* UMi */
|
|
, { 15, 23.58333333333333, 24.00000000000000, 66.00000000000000 } /* Cep */
|
|
, { 33, 12.00000000000000, 13.50000000000000, 64.00000000000000 } /* Dra */
|
|
, { 33, 13.50000000000000, 14.41666666666667, 63.00000000000000 } /* Dra */
|
|
, { 15, 23.16666666666667, 23.58333333333333, 63.00000000000000 } /* Cep */
|
|
, { 10, 6.10000000000000, 7.00000000000000, 62.00000000000000 } /* Cam */
|
|
, { 33, 20.00000000000000, 20.41666666666667, 61.50000000000000 } /* Dra */
|
|
, { 15, 20.53666666666667, 20.60000000000000, 60.91666666666666 } /* Cep */
|
|
, { 10, 7.00000000000000, 7.96666666666667, 60.00000000000000 } /* Cam */
|
|
, { 82, 7.96666666666667, 8.41666666666667, 60.00000000000000 } /* UMa */
|
|
, { 33, 19.76666666666667, 20.00000000000000, 59.50000000000000 } /* Dra */
|
|
, { 15, 20.00000000000000, 20.53666666666667, 59.50000000000000 } /* Cep */
|
|
, { 15, 22.86666666666667, 23.16666666666667, 59.08333333333334 } /* Cep */
|
|
, { 13, 0.00000000000000, 2.43333333333333, 58.50000000000000 } /* Cas */
|
|
, { 33, 19.41666666666667, 19.76666666666667, 58.00000000000000 } /* Dra */
|
|
, { 13, 1.70000000000000, 1.90833333333333, 57.50000000000000 } /* Cas */
|
|
, { 13, 2.43333333333333, 3.10000000000000, 57.00000000000000 } /* Cas */
|
|
, { 10, 3.10000000000000, 3.16666666666667, 57.00000000000000 } /* Cam */
|
|
, { 15, 22.31666666666667, 22.86666666666667, 56.25000000000000 } /* Cep */
|
|
, { 10, 5.00000000000000, 6.10000000000000, 56.00000000000000 } /* Cam */
|
|
, { 82, 14.03333333333333, 14.41666666666667, 55.50000000000000 } /* UMa */
|
|
, { 33, 14.41666666666667, 19.41666666666667, 55.50000000000000 } /* Dra */
|
|
, { 10, 3.16666666666667, 3.33333333333333, 55.00000000000000 } /* Cam */
|
|
, { 15, 22.13333333333333, 22.31666666666667, 55.00000000000000 } /* Cep */
|
|
, { 15, 20.60000000000000, 21.96666666666667, 54.83333333333334 } /* Cep */
|
|
, { 13, 0.00000000000000, 1.70000000000000, 54.00000000000000 } /* Cas */
|
|
, { 50, 6.10000000000000, 6.50000000000000, 54.00000000000000 } /* Lyn */
|
|
, { 82, 12.08333333333333, 13.50000000000000, 53.00000000000000 } /* UMa */
|
|
, { 33, 15.25000000000000, 15.75000000000000, 53.00000000000000 } /* Dra */
|
|
, { 15, 21.96666666666667, 22.13333333333333, 52.75000000000000 } /* Cep */
|
|
, { 10, 3.33333333333333, 5.00000000000000, 52.50000000000000 } /* Cam */
|
|
, { 13, 22.86666666666667, 23.33333333333333, 52.50000000000000 } /* Cas */
|
|
, { 33, 15.75000000000000, 17.00000000000000, 51.50000000000000 } /* Dra */
|
|
, { 62, 2.04166666666667, 2.51666666666667, 50.50000000000000 } /* Per */
|
|
, { 33, 17.00000000000000, 18.23333333333333, 50.50000000000000 } /* Dra */
|
|
, { 13, 0.00000000000000, 1.36666666666667, 50.00000000000000 } /* Cas */
|
|
, { 62, 1.36666666666667, 1.66666666666667, 50.00000000000000 } /* Per */
|
|
, { 50, 6.50000000000000, 6.80000000000000, 50.00000000000000 } /* Lyn */
|
|
, { 13, 23.33333333333333, 24.00000000000000, 50.00000000000000 } /* Cas */
|
|
, { 82, 13.50000000000000, 14.03333333333333, 48.50000000000000 } /* UMa */
|
|
, { 13, 0.00000000000000, 1.11666666666667, 48.00000000000000 } /* Cas */
|
|
, { 13, 23.58333333333333, 24.00000000000000, 48.00000000000000 } /* Cas */
|
|
, { 39, 18.17500000000000, 18.23333333333333, 47.50000000000000 } /* Her */
|
|
, { 33, 18.23333333333333, 19.08333333333333, 47.50000000000000 } /* Dra */
|
|
, { 30, 19.08333333333333, 19.16666666666667, 47.50000000000000 } /* Cyg */
|
|
, { 62, 1.66666666666667, 2.04166666666667, 47.00000000000000 } /* Per */
|
|
, { 82, 8.41666666666667, 9.16666666666667, 47.00000000000000 } /* UMa */
|
|
, { 13, 0.16666666666667, 0.86666666666667, 46.00000000000000 } /* Cas */
|
|
, { 82, 12.00000000000000, 12.08333333333333, 45.00000000000000 } /* UMa */
|
|
, { 50, 6.80000000000000, 7.36666666666667, 44.50000000000000 } /* Lyn */
|
|
, { 30, 21.90833333333333, 21.96666666666667, 44.00000000000000 } /* Cyg */
|
|
, { 30, 21.87500000000000, 21.90833333333333, 43.75000000000000 } /* Cyg */
|
|
, { 30, 19.16666666666667, 19.40000000000000, 43.50000000000000 } /* Cyg */
|
|
, { 82, 9.16666666666667, 10.16666666666667, 42.00000000000000 } /* UMa */
|
|
, { 82, 10.16666666666667, 10.78333333333333, 40.00000000000000 } /* UMa */
|
|
, { 8, 15.43333333333333, 15.75000000000000, 40.00000000000000 } /* Boo */
|
|
, { 39, 15.75000000000000, 16.33333333333333, 40.00000000000000 } /* Her */
|
|
, { 50, 9.25000000000000, 9.58333333333333, 39.75000000000000 } /* Lyn */
|
|
, { 0, 0.00000000000000, 2.51666666666667, 36.75000000000000 } /* And */
|
|
, { 62, 2.51666666666667, 2.56666666666667, 36.75000000000000 } /* Per */
|
|
, { 51, 19.35833333333333, 19.40000000000000, 36.50000000000000 } /* Lyr */
|
|
, { 62, 4.50000000000000, 4.69166666666667, 36.00000000000000 } /* Per */
|
|
, { 30, 21.73333333333333, 21.87500000000000, 36.00000000000000 } /* Cyg */
|
|
, { 44, 21.87500000000000, 22.00000000000000, 36.00000000000000 } /* Lac */
|
|
, { 7, 6.53333333333333, 7.36666666666667, 35.50000000000000 } /* Aur */
|
|
, { 50, 7.36666666666667, 7.75000000000000, 35.50000000000000 } /* Lyn */
|
|
, { 0, 0.00000000000000, 2.00000000000000, 35.00000000000000 } /* And */
|
|
, { 44, 22.00000000000000, 22.81666666666667, 35.00000000000000 } /* Lac */
|
|
, { 44, 22.81666666666667, 22.86666666666667, 34.50000000000000 } /* Lac */
|
|
, { 0, 22.86666666666667, 23.50000000000000, 34.50000000000000 } /* And */
|
|
, { 62, 2.56666666666667, 2.71666666666667, 34.00000000000000 } /* Per */
|
|
, { 82, 10.78333333333333, 11.00000000000000, 34.00000000000000 } /* UMa */
|
|
, { 29, 12.00000000000000, 12.33333333333333, 34.00000000000000 } /* CVn */
|
|
, { 50, 7.75000000000000, 9.25000000000000, 33.50000000000000 } /* Lyn */
|
|
, { 48, 9.25000000000000, 9.88333333333333, 33.50000000000000 } /* LMi */
|
|
, { 0, 0.71666666666667, 1.40833333333333, 33.00000000000000 } /* And */
|
|
, { 8, 15.18333333333333, 15.43333333333333, 33.00000000000000 } /* Boo */
|
|
, { 0, 23.50000000000000, 23.75000000000000, 32.08333333333334 } /* And */
|
|
, { 29, 12.33333333333333, 13.25000000000000, 32.00000000000000 } /* CVn */
|
|
, { 0, 23.75000000000000, 24.00000000000000, 31.33333333333333 } /* And */
|
|
, { 29, 13.95833333333333, 14.03333333333333, 30.75000000000000 } /* CVn */
|
|
, { 80, 2.41666666666667, 2.71666666666667, 30.66666666666667 } /* Tri */
|
|
, { 62, 2.71666666666667, 4.50000000000000, 30.66666666666667 } /* Per */
|
|
, { 7, 4.50000000000000, 4.75000000000000, 30.00000000000000 } /* Aur */
|
|
, { 51, 18.17500000000000, 19.35833333333333, 30.00000000000000 } /* Lyr */
|
|
, { 82, 11.00000000000000, 12.00000000000000, 29.00000000000000 } /* UMa */
|
|
, { 30, 19.66666666666667, 20.91666666666667, 29.00000000000000 } /* Cyg */
|
|
, { 7, 4.75000000000000, 5.88333333333333, 28.50000000000000 } /* Aur */
|
|
, { 48, 9.88333333333333, 10.50000000000000, 28.50000000000000 } /* LMi */
|
|
, { 29, 13.25000000000000, 13.95833333333333, 28.50000000000000 } /* CVn */
|
|
, { 0, 0.00000000000000, 0.06666666666667, 28.00000000000000 } /* And */
|
|
, { 80, 1.40833333333333, 1.66666666666667, 28.00000000000000 } /* Tri */
|
|
, { 7, 5.88333333333333, 6.53333333333333, 28.00000000000000 } /* Aur */
|
|
, { 37, 7.88333333333333, 8.00000000000000, 28.00000000000000 } /* Gem */
|
|
, { 30, 20.91666666666667, 21.73333333333333, 28.00000000000000 } /* Cyg */
|
|
, { 30, 19.25833333333333, 19.66666666666667, 27.50000000000000 } /* Cyg */
|
|
, { 80, 1.91666666666667, 2.41666666666667, 27.25000000000000 } /* Tri */
|
|
, { 25, 16.16666666666667, 16.33333333333333, 27.00000000000000 } /* CrB */
|
|
, { 8, 15.08333333333333, 15.18333333333333, 26.00000000000000 } /* Boo */
|
|
, { 25, 15.18333333333333, 16.16666666666667, 26.00000000000000 } /* CrB */
|
|
, { 51, 18.36666666666667, 18.86666666666667, 26.00000000000000 } /* Lyr */
|
|
, { 48, 10.75000000000000, 11.00000000000000, 25.50000000000000 } /* LMi */
|
|
, { 51, 18.86666666666667, 19.25833333333333, 25.50000000000000 } /* Lyr */
|
|
, { 80, 1.66666666666667, 1.91666666666667, 25.00000000000000 } /* Tri */
|
|
, { 66, 0.71666666666667, 0.85000000000000, 23.75000000000000 } /* Psc */
|
|
, { 48, 10.50000000000000, 10.75000000000000, 23.50000000000000 } /* LMi */
|
|
, { 87, 21.25000000000000, 21.41666666666667, 23.50000000000000 } /* Vul */
|
|
, { 77, 5.70000000000000, 5.88333333333333, 22.83333333333333 } /* Tau */
|
|
, { 0, 0.06666666666667, 0.14166666666667, 22.00000000000000 } /* And */
|
|
, { 73, 15.91666666666667, 16.03333333333333, 22.00000000000000 } /* Ser */
|
|
, { 37, 5.88333333333333, 6.21666666666667, 21.50000000000000 } /* Gem */
|
|
, { 87, 19.83333333333333, 20.25000000000000, 21.25000000000000 } /* Vul */
|
|
, { 87, 18.86666666666667, 19.25000000000000, 21.08333333333333 } /* Vul */
|
|
, { 0, 0.14166666666667, 0.85000000000000, 21.00000000000000 } /* And */
|
|
, { 87, 20.25000000000000, 20.56666666666667, 20.50000000000000 } /* Vul */
|
|
, { 37, 7.80833333333333, 7.88333333333333, 20.00000000000000 } /* Gem */
|
|
, { 87, 20.56666666666667, 21.25000000000000, 19.50000000000000 } /* Vul */
|
|
, { 87, 19.25000000000000, 19.83333333333333, 19.16666666666667 } /* Vul */
|
|
, { 6, 3.28333333333333, 3.36666666666667, 19.00000000000000 } /* Ari */
|
|
, { 75, 18.86666666666667, 19.00000000000000, 18.50000000000000 } /* Sge */
|
|
, { 59, 5.70000000000000, 5.76666666666667, 18.00000000000000 } /* Ori */
|
|
, { 37, 6.21666666666667, 6.30833333333333, 17.50000000000000 } /* Gem */
|
|
, { 75, 19.00000000000000, 19.83333333333333, 16.16666666666667 } /* Sge */
|
|
, { 77, 4.96666666666667, 5.33333333333333, 16.00000000000000 } /* Tau */
|
|
, { 39, 15.91666666666667, 16.08333333333333, 16.00000000000000 } /* Her */
|
|
, { 75, 19.83333333333333, 20.25000000000000, 15.75000000000000 } /* Sge */
|
|
, { 77, 4.61666666666667, 4.96666666666667, 15.50000000000000 } /* Tau */
|
|
, { 77, 5.33333333333333, 5.60000000000000, 15.50000000000000 } /* Tau */
|
|
, { 23, 12.83333333333333, 13.50000000000000, 15.00000000000000 } /* Com */
|
|
, { 39, 17.25000000000000, 18.25000000000000, 14.33333333333333 } /* Her */
|
|
, { 23, 11.86666666666667, 12.83333333333333, 14.00000000000000 } /* Com */
|
|
, { 37, 7.50000000000000, 7.80833333333333, 13.50000000000000 } /* Gem */
|
|
, { 39, 16.75000000000000, 17.25000000000000, 12.83333333333333 } /* Her */
|
|
, { 61, 0.00000000000000, 0.14166666666667, 12.50000000000000 } /* Peg */
|
|
, { 77, 5.60000000000000, 5.76666666666667, 12.50000000000000 } /* Tau */
|
|
, { 37, 7.00000000000000, 7.50000000000000, 12.50000000000000 } /* Gem */
|
|
, { 61, 21.11666666666667, 21.33333333333333, 12.50000000000000 } /* Peg */
|
|
, { 37, 6.30833333333333, 6.93333333333333, 12.00000000000000 } /* Gem */
|
|
, { 39, 18.25000000000000, 18.86666666666667, 12.00000000000000 } /* Her */
|
|
, { 31, 20.87500000000000, 21.05000000000000, 11.83333333333333 } /* Del */
|
|
, { 61, 21.05000000000000, 21.11666666666667, 11.83333333333333 } /* Peg */
|
|
, { 45, 11.51666666666667, 11.86666666666667, 11.00000000000000 } /* Leo */
|
|
, { 59, 6.24166666666667, 6.30833333333333, 10.00000000000000 } /* Ori */
|
|
, { 37, 6.93333333333333, 7.00000000000000, 10.00000000000000 } /* Gem */
|
|
, { 21, 7.80833333333333, 7.92500000000000, 10.00000000000000 } /* Cnc */
|
|
, { 61, 23.83333333333333, 24.00000000000000, 10.00000000000000 } /* Peg */
|
|
, { 6, 1.66666666666667, 3.28333333333333, 9.91666666666667 } /* Ari */
|
|
, { 31, 20.14166666666667, 20.30000000000000, 8.50000000000000 } /* Del */
|
|
, { 8, 13.50000000000000, 15.08333333333333, 8.00000000000000 } /* Boo */
|
|
, { 61, 22.75000000000000, 23.83333333333333, 7.50000000000000 } /* Peg */
|
|
, { 21, 7.92500000000000, 9.25000000000000, 7.00000000000000 } /* Cnc */
|
|
, { 45, 9.25000000000000, 10.75000000000000, 7.00000000000000 } /* Leo */
|
|
, { 58, 18.25000000000000, 18.66222222222222, 6.25000000000000 } /* Oph */
|
|
, { 3, 18.66222222222222, 18.86666666666667, 6.25000000000000 } /* Aql */
|
|
, { 31, 20.83333333333333, 20.87500000000000, 6.00000000000000 } /* Del */
|
|
, { 20, 7.00000000000000, 7.01666666666667, 5.50000000000000 } /* CMi */
|
|
, { 73, 18.25000000000000, 18.42500000000000, 4.50000000000000 } /* Ser */
|
|
, { 39, 16.08333333333333, 16.75000000000000, 4.00000000000000 } /* Her */
|
|
, { 58, 18.25000000000000, 18.42500000000000, 3.00000000000000 } /* Oph */
|
|
, { 61, 21.46666666666667, 21.66666666666667, 2.75000000000000 } /* Peg */
|
|
, { 66, 0.00000000000000, 2.00000000000000, 2.00000000000000 } /* Psc */
|
|
, { 73, 18.58333333333333, 18.86666666666667, 2.00000000000000 } /* Ser */
|
|
, { 31, 20.30000000000000, 20.83333333333333, 2.00000000000000 } /* Del */
|
|
, { 34, 20.83333333333333, 21.33333333333333, 2.00000000000000 } /* Equ */
|
|
, { 61, 21.33333333333333, 21.46666666666667, 2.00000000000000 } /* Peg */
|
|
, { 61, 22.00000000000000, 22.75000000000000, 2.00000000000000 } /* Peg */
|
|
, { 61, 21.66666666666667, 22.00000000000000, 1.75000000000000 } /* Peg */
|
|
, { 20, 7.01666666666667, 7.20000000000000, 1.50000000000000 } /* CMi */
|
|
, { 77, 3.58333333333333, 4.61666666666667, 0.00000000000000 } /* Tau */
|
|
, { 59, 4.61666666666667, 4.66666666666667, 0.00000000000000 } /* Ori */
|
|
, { 20, 7.20000000000000, 8.08333333333333, 0.00000000000000 } /* CMi */
|
|
, { 85, 14.66666666666667, 15.08333333333333, 0.00000000000000 } /* Vir */
|
|
, { 58, 17.83333333333333, 18.25000000000000, 0.00000000000000 } /* Oph */
|
|
, { 16, 2.65000000000000, 3.28333333333333, -1.75000000000000 } /* Cet */
|
|
, { 77, 3.28333333333333, 3.58333333333333, -1.75000000000000 } /* Tau */
|
|
, { 73, 15.08333333333333, 16.26666666666667, -3.25000000000000 } /* Ser */
|
|
, { 59, 4.66666666666667, 5.08333333333333, -4.00000000000000 } /* Ori */
|
|
, { 59, 5.83333333333333, 6.24166666666667, -4.00000000000000 } /* Ori */
|
|
, { 73, 17.83333333333333, 17.96666666666667, -4.00000000000000 } /* Ser */
|
|
, { 73, 18.25000000000000, 18.58333333333333, -4.00000000000000 } /* Ser */
|
|
, { 3, 18.58333333333333, 18.86666666666667, -4.00000000000000 } /* Aql */
|
|
, { 66, 22.75000000000000, 23.83333333333333, -4.00000000000000 } /* Psc */
|
|
, { 45, 10.75000000000000, 11.51666666666667, -6.00000000000000 } /* Leo */
|
|
, { 85, 11.51666666666667, 11.83333333333333, -6.00000000000000 } /* Vir */
|
|
, { 66, 0.00000000000000, 0.33333333333333, -7.00000000000000 } /* Psc */
|
|
, { 66, 23.83333333333333, 24.00000000000000, -7.00000000000000 } /* Psc */
|
|
, { 85, 14.25000000000000, 14.66666666666667, -8.00000000000000 } /* Vir */
|
|
, { 58, 15.91666666666667, 16.26666666666667, -8.00000000000000 } /* Oph */
|
|
, { 3, 20.00000000000000, 20.53333333333333, -9.00000000000000 } /* Aql */
|
|
, { 4, 21.33333333333333, 21.86666666666667, -9.00000000000000 } /* Aqr */
|
|
, { 58, 17.16666666666667, 17.96666666666667, -10.00000000000000 } /* Oph */
|
|
, { 54, 5.83333333333333, 8.08333333333333, -11.00000000000000 } /* Mon */
|
|
, { 35, 4.91666666666667, 5.08333333333333, -11.00000000000000 } /* Eri */
|
|
, { 59, 5.08333333333333, 5.83333333333333, -11.00000000000000 } /* Ori */
|
|
, { 41, 8.08333333333333, 8.36666666666667, -11.00000000000000 } /* Hya */
|
|
, { 74, 9.58333333333333, 10.75000000000000, -11.00000000000000 } /* Sex */
|
|
, { 85, 11.83333333333333, 12.83333333333333, -11.00000000000000 } /* Vir */
|
|
, { 58, 17.58333333333333, 17.66666666666667, -11.66666666666667 } /* Oph */
|
|
, { 3, 18.86666666666667, 20.00000000000000, -12.03333333333333 } /* Aql */
|
|
, { 35, 4.83333333333333, 4.91666666666667, -14.50000000000000 } /* Eri */
|
|
, { 4, 20.53333333333333, 21.33333333333333, -15.00000000000000 } /* Aqr */
|
|
, { 73, 17.16666666666667, 18.25000000000000, -16.00000000000000 } /* Ser */
|
|
, { 72, 18.25000000000000, 18.86666666666667, -16.00000000000000 } /* Sct */
|
|
, { 41, 8.36666666666667, 8.58333333333333, -17.00000000000000 } /* Hya */
|
|
, { 58, 16.26666666666667, 16.37500000000000, -18.25000000000000 } /* Oph */
|
|
, { 41, 8.58333333333333, 9.08333333333333, -19.00000000000000 } /* Hya */
|
|
, { 26, 10.75000000000000, 10.83333333333333, -19.00000000000000 } /* Crt */
|
|
, { 71, 16.26666666666667, 16.37500000000000, -19.25000000000000 } /* Sco */
|
|
, { 47, 15.66666666666667, 15.91666666666667, -20.00000000000000 } /* Lib */
|
|
, { 28, 12.58333333333333, 12.83333333333333, -22.00000000000000 } /* Crv */
|
|
, { 85, 12.83333333333333, 14.25000000000000, -22.00000000000000 } /* Vir */
|
|
, { 41, 9.08333333333333, 9.75000000000000, -24.00000000000000 } /* Hya */
|
|
, { 16, 1.66666666666667, 2.65000000000000, -24.38333333333333 } /* Cet */
|
|
, { 35, 2.65000000000000, 3.75000000000000, -24.38333333333333 } /* Eri */
|
|
, { 26, 10.83333333333333, 11.83333333333333, -24.50000000000000 } /* Crt */
|
|
, { 28, 11.83333333333333, 12.58333333333333, -24.50000000000000 } /* Crv */
|
|
, { 47, 14.25000000000000, 14.91666666666667, -24.50000000000000 } /* Lib */
|
|
, { 58, 16.26666666666667, 16.75000000000000, -24.58333333333333 } /* Oph */
|
|
, { 16, 0.00000000000000, 1.66666666666667, -25.50000000000000 } /* Cet */
|
|
, { 11, 21.33333333333333, 21.86666666666667, -25.50000000000000 } /* Cap */
|
|
, { 4, 21.86666666666667, 23.83333333333333, -25.50000000000000 } /* Aqr */
|
|
, { 16, 23.83333333333333, 24.00000000000000, -25.50000000000000 } /* Cet */
|
|
, { 41, 9.75000000000000, 10.25000000000000, -26.50000000000000 } /* Hya */
|
|
, { 35, 4.70000000000000, 4.83333333333333, -27.25000000000000 } /* Eri */
|
|
, { 46, 4.83333333333333, 6.11666666666667, -27.25000000000000 } /* Lep */
|
|
, { 11, 20.00000000000000, 21.33333333333333, -28.00000000000000 } /* Cap */
|
|
, { 41, 10.25000000000000, 10.58333333333333, -29.16666666666667 } /* Hya */
|
|
, { 41, 12.58333333333333, 14.91666666666667, -29.50000000000000 } /* Hya */
|
|
, { 47, 14.91666666666667, 15.66666666666667, -29.50000000000000 } /* Lib */
|
|
, { 71, 15.66666666666667, 16.00000000000000, -29.50000000000000 } /* Sco */
|
|
, { 35, 4.58333333333333, 4.70000000000000, -30.00000000000000 } /* Eri */
|
|
, { 58, 16.75000000000000, 17.60000000000000, -30.00000000000000 } /* Oph */
|
|
, { 76, 17.60000000000000, 17.83333333333333, -30.00000000000000 } /* Sgr */
|
|
, { 41, 10.58333333333333, 10.83333333333333, -31.16666666666667 } /* Hya */
|
|
, { 19, 6.11666666666667, 7.36666666666667, -33.00000000000000 } /* CMa */
|
|
, { 41, 12.25000000000000, 12.58333333333333, -33.00000000000000 } /* Hya */
|
|
, { 41, 10.83333333333333, 12.25000000000000, -35.00000000000000 } /* Hya */
|
|
, { 36, 3.50000000000000, 3.75000000000000, -36.00000000000000 } /* For */
|
|
, { 68, 8.36666666666667, 9.36666666666667, -36.75000000000000 } /* Pyx */
|
|
, { 35, 4.26666666666667, 4.58333333333333, -37.00000000000000 } /* Eri */
|
|
, { 76, 17.83333333333333, 19.16666666666667, -37.00000000000000 } /* Sgr */
|
|
, { 65, 21.33333333333333, 23.00000000000000, -37.00000000000000 } /* PsA */
|
|
, { 70, 23.00000000000000, 23.33333333333333, -37.00000000000000 } /* Scl */
|
|
, { 36, 3.00000000000000, 3.50000000000000, -39.58333333333334 } /* For */
|
|
, { 1, 9.36666666666667, 11.00000000000000, -39.75000000000000 } /* Ant */
|
|
, { 70, 0.00000000000000, 1.66666666666667, -40.00000000000000 } /* Scl */
|
|
, { 36, 1.66666666666667, 3.00000000000000, -40.00000000000000 } /* For */
|
|
, { 35, 3.86666666666667, 4.26666666666667, -40.00000000000000 } /* Eri */
|
|
, { 70, 23.33333333333333, 24.00000000000000, -40.00000000000000 } /* Scl */
|
|
, { 14, 14.16666666666667, 14.91666666666667, -42.00000000000000 } /* Cen */
|
|
, { 49, 15.66666666666667, 16.00000000000000, -42.00000000000000 } /* Lup */
|
|
, { 71, 16.00000000000000, 16.42083333333333, -42.00000000000000 } /* Sco */
|
|
, { 9, 4.83333333333333, 5.00000000000000, -43.00000000000000 } /* Cae */
|
|
, { 22, 5.00000000000000, 6.58333333333333, -43.00000000000000 } /* Col */
|
|
, { 67, 8.00000000000000, 8.36666666666667, -43.00000000000000 } /* Pup */
|
|
, { 35, 3.41666666666667, 3.86666666666667, -44.00000000000000 } /* Eri */
|
|
, { 71, 16.42083333333333, 17.83333333333333, -45.50000000000000 } /* Sco */
|
|
, { 24, 17.83333333333333, 19.16666666666667, -45.50000000000000 } /* CrA */
|
|
, { 76, 19.16666666666667, 20.33333333333333, -45.50000000000000 } /* Sgr */
|
|
, { 53, 20.33333333333333, 21.33333333333333, -45.50000000000000 } /* Mic */
|
|
, { 35, 3.00000000000000, 3.41666666666667, -46.00000000000000 } /* Eri */
|
|
, { 9, 4.50000000000000, 4.83333333333333, -46.50000000000000 } /* Cae */
|
|
, { 49, 15.33333333333333, 15.66666666666667, -48.00000000000000 } /* Lup */
|
|
, { 63, 0.00000000000000, 2.33333333333333, -48.16666666666666 } /* Phe */
|
|
, { 35, 2.66666666666667, 3.00000000000000, -49.00000000000000 } /* Eri */
|
|
, { 40, 4.08333333333333, 4.26666666666667, -49.00000000000000 } /* Hor */
|
|
, { 9, 4.26666666666667, 4.50000000000000, -49.00000000000000 } /* Cae */
|
|
, { 38, 21.33333333333333, 22.00000000000000, -50.00000000000000 } /* Gru */
|
|
, { 67, 6.00000000000000, 8.00000000000000, -50.75000000000000 } /* Pup */
|
|
, { 84, 8.00000000000000, 8.16666666666667, -50.75000000000000 } /* Vel */
|
|
, { 35, 2.41666666666667, 2.66666666666667, -51.00000000000000 } /* Eri */
|
|
, { 40, 3.83333333333333, 4.08333333333333, -51.00000000000000 } /* Hor */
|
|
, { 63, 0.00000000000000, 1.83333333333333, -51.50000000000000 } /* Phe */
|
|
, { 12, 6.00000000000000, 6.16666666666667, -52.50000000000000 } /* Car */
|
|
, { 84, 8.16666666666667, 8.45000000000000, -53.00000000000000 } /* Vel */
|
|
, { 40, 3.50000000000000, 3.83333333333333, -53.16666666666666 } /* Hor */
|
|
, { 32, 3.83333333333333, 4.00000000000000, -53.16666666666666 } /* Dor */
|
|
, { 63, 0.00000000000000, 1.58333333333333, -53.50000000000000 } /* Phe */
|
|
, { 35, 2.16666666666667, 2.41666666666667, -54.00000000000000 } /* Eri */
|
|
, { 64, 4.50000000000000, 5.00000000000000, -54.00000000000000 } /* Pic */
|
|
, { 49, 15.05000000000000, 15.33333333333333, -54.00000000000000 } /* Lup */
|
|
, { 84, 8.45000000000000, 8.83333333333333, -54.50000000000000 } /* Vel */
|
|
, { 12, 6.16666666666667, 6.50000000000000, -55.00000000000000 } /* Car */
|
|
, { 14, 11.83333333333333, 12.83333333333333, -55.00000000000000 } /* Cen */
|
|
, { 49, 14.16666666666667, 15.05000000000000, -55.00000000000000 } /* Lup */
|
|
, { 56, 15.05000000000000, 15.33333333333333, -55.00000000000000 } /* Nor */
|
|
, { 32, 4.00000000000000, 4.33333333333333, -56.50000000000000 } /* Dor */
|
|
, { 84, 8.83333333333333, 11.00000000000000, -56.50000000000000 } /* Vel */
|
|
, { 14, 11.00000000000000, 11.25000000000000, -56.50000000000000 } /* Cen */
|
|
, { 5, 17.50000000000000, 18.00000000000000, -57.00000000000000 } /* Ara */
|
|
, { 78, 18.00000000000000, 20.33333333333333, -57.00000000000000 } /* Tel */
|
|
, { 38, 22.00000000000000, 23.33333333333333, -57.00000000000000 } /* Gru */
|
|
, { 40, 3.20000000000000, 3.50000000000000, -57.50000000000000 } /* Hor */
|
|
, { 64, 5.00000000000000, 5.50000000000000, -57.50000000000000 } /* Pic */
|
|
, { 12, 6.50000000000000, 6.83333333333333, -58.00000000000000 } /* Car */
|
|
, { 63, 0.00000000000000, 1.33333333333333, -58.50000000000000 } /* Phe */
|
|
, { 35, 1.33333333333333, 2.16666666666667, -58.50000000000000 } /* Eri */
|
|
, { 63, 23.33333333333333, 24.00000000000000, -58.50000000000000 } /* Phe */
|
|
, { 32, 4.33333333333333, 4.58333333333333, -59.00000000000000 } /* Dor */
|
|
, { 56, 15.33333333333333, 16.42083333333333, -60.00000000000000 } /* Nor */
|
|
, { 43, 20.33333333333333, 21.33333333333333, -60.00000000000000 } /* Ind */
|
|
, { 64, 5.50000000000000, 6.00000000000000, -61.00000000000000 } /* Pic */
|
|
, { 18, 15.16666666666667, 15.33333333333333, -61.00000000000000 } /* Cir */
|
|
, { 5, 16.42083333333333, 16.58333333333333, -61.00000000000000 } /* Ara */
|
|
, { 18, 14.91666666666667, 15.16666666666667, -63.58333333333334 } /* Cir */
|
|
, { 5, 16.58333333333333, 16.75000000000000, -63.58333333333334 } /* Ara */
|
|
, { 64, 6.00000000000000, 6.83333333333333, -64.00000000000000 } /* Pic */
|
|
, { 12, 6.83333333333333, 9.03333333333333, -64.00000000000000 } /* Car */
|
|
, { 14, 11.25000000000000, 11.83333333333333, -64.00000000000000 } /* Cen */
|
|
, { 27, 11.83333333333333, 12.83333333333333, -64.00000000000000 } /* Cru */
|
|
, { 14, 12.83333333333333, 14.53333333333333, -64.00000000000000 } /* Cen */
|
|
, { 18, 13.50000000000000, 13.66666666666667, -65.00000000000000 } /* Cir */
|
|
, { 5, 16.75000000000000, 16.83333333333333, -65.00000000000000 } /* Ara */
|
|
, { 40, 2.16666666666667, 3.20000000000000, -67.50000000000000 } /* Hor */
|
|
, { 69, 3.20000000000000, 4.58333333333333, -67.50000000000000 } /* Ret */
|
|
, { 18, 14.75000000000000, 14.91666666666667, -67.50000000000000 } /* Cir */
|
|
, { 5, 16.83333333333333, 17.50000000000000, -67.50000000000000 } /* Ara */
|
|
, { 60, 17.50000000000000, 18.00000000000000, -67.50000000000000 } /* Pav */
|
|
, { 81, 22.00000000000000, 23.33333333333333, -67.50000000000000 } /* Tuc */
|
|
, { 32, 4.58333333333333, 6.58333333333333, -70.00000000000000 } /* Dor */
|
|
, { 18, 13.66666666666667, 14.75000000000000, -70.00000000000000 } /* Cir */
|
|
, { 79, 14.75000000000000, 17.00000000000000, -70.00000000000000 } /* TrA */
|
|
, { 81, 0.00000000000000, 1.33333333333333, -75.00000000000000 } /* Tuc */
|
|
, { 42, 3.50000000000000, 4.58333333333333, -75.00000000000000 } /* Hyi */
|
|
, { 86, 6.58333333333333, 9.03333333333333, -75.00000000000000 } /* Vol */
|
|
, { 12, 9.03333333333333, 11.25000000000000, -75.00000000000000 } /* Car */
|
|
, { 55, 11.25000000000000, 13.66666666666667, -75.00000000000000 } /* Mus */
|
|
, { 60, 18.00000000000000, 21.33333333333333, -75.00000000000000 } /* Pav */
|
|
, { 43, 21.33333333333333, 23.33333333333333, -75.00000000000000 } /* Ind */
|
|
, { 81, 23.33333333333333, 24.00000000000000, -75.00000000000000 } /* Tuc */
|
|
, { 81, 0.75000000000000, 1.33333333333333, -76.00000000000000 } /* Tuc */
|
|
, { 42, 0.00000000000000, 3.50000000000000, -82.50000000000000 } /* Hyi */
|
|
, { 17, 7.66666666666667, 13.66666666666667, -82.50000000000000 } /* Cha */
|
|
, { 2, 13.66666666666667, 18.00000000000000, -82.50000000000000 } /* Aps */
|
|
, { 52, 3.50000000000000, 7.66666666666667, -85.00000000000000 } /* Men */
|
|
, { 57, 0.00000000000000, 24.00000000000000, -90.00000000000000 } /* Oct */
|
|
};
|
|
|
|
#define NUM_CONSTEL_BOUNDARIES 357
|
|
|
|
|
|
|
|
/**
|
|
* @brief
|
|
* Determines the constellation that contains the given point in the sky.
|
|
*
|
|
* Given J2000 equatorial (EQJ) coordinates of a point in the sky, determines the
|
|
* constellation that contains that point.
|
|
*
|
|
* @param ra
|
|
* The right ascension (RA) of a point in the sky, using the J2000 equatorial system.
|
|
*
|
|
* @param dec
|
|
* The declination (DEC) of a point in the sky, using the J2000 equatorial system.
|
|
*
|
|
* @return
|
|
* If successful, `status` holds `ASTRO_SUCCESS`,
|
|
* `symbol` holds a pointer to a 3-character string like "Ori", and
|
|
* `name` holds a pointer to the full constellation name like "Orion".
|
|
*/
|
|
astro_constellation_t Astronomy_Constellation(double ra, double dec)
|
|
{
|
|
static astro_time_t epoch2000;
|
|
static astro_rotation_t rot = { ASTRO_NOT_INITIALIZED };
|
|
astro_constellation_t constel;
|
|
astro_equatorial_t j2000, b1875;
|
|
astro_vector_t vec2000, vec1875;
|
|
int i, c;
|
|
|
|
if (dec < -90.0 || dec > +90.0)
|
|
return ConstelErr(ASTRO_INVALID_PARAMETER);
|
|
|
|
/* Allow right ascension to "wrap around". Clamp to [0, 24) sidereal hours. */
|
|
ra = fmod(ra, 24.0);
|
|
if (ra < 0.0)
|
|
ra += 24.0;
|
|
|
|
/* Lazy-initialize the rotation matrix for converting J2000 to B1875. */
|
|
if (rot.status != ASTRO_SUCCESS)
|
|
{
|
|
/*
|
|
Need to calculate the B1875 epoch. Based on this:
|
|
https://en.wikipedia.org/wiki/Epoch_(astronomy)#Besselian_years
|
|
B = 1900 + (JD - 2415020.31352) / 365.242198781
|
|
I'm interested in using TT instead of JD, giving:
|
|
B = 1900 + ((TT+2451545) - 2415020.31352) / 365.242198781
|
|
B = 1900 + (TT + 36524.68648) / 365.242198781
|
|
TT = 365.242198781*(B - 1900) - 36524.68648 = -45655.741449525
|
|
But Astronomy_TimeFromDays() wants UT, not TT.
|
|
Near that date, I get a historical correction of ut-tt = 3.2 seconds.
|
|
That gives UT = -45655.74141261017 for the B1875 epoch,
|
|
or 1874-12-31T18:12:21.950Z.
|
|
*/
|
|
astro_time_t time = Astronomy_TimeFromDays(-45655.74141261017);
|
|
rot = Astronomy_Rotation_EQJ_EQD(time);
|
|
if (rot.status != ASTRO_SUCCESS)
|
|
return ConstelErr(rot.status);
|
|
|
|
epoch2000 = Astronomy_TimeFromDays(0.0);
|
|
}
|
|
|
|
/* Convert coordinates from J2000 to year 1875. */
|
|
j2000.status = ASTRO_SUCCESS;
|
|
j2000.ra = ra;
|
|
j2000.dec = dec;
|
|
j2000.dist = 1.0;
|
|
vec2000 = Astronomy_VectorFromEquator(j2000, epoch2000);
|
|
if (vec2000.status != ASTRO_SUCCESS)
|
|
return ConstelErr(vec2000.status);
|
|
|
|
vec1875 = Astronomy_RotateVector(rot, vec2000);
|
|
if (vec1875.status != ASTRO_SUCCESS)
|
|
return ConstelErr(vec1875.status);
|
|
|
|
b1875 = Astronomy_EquatorFromVector(vec1875);
|
|
if (b1875.status != ASTRO_SUCCESS)
|
|
return ConstelErr(b1875.status);
|
|
|
|
/* Search for the constellation using the B1875 coordinates. */
|
|
c = -1; /* constellation not (yet) found */
|
|
for (i=0; i < NUM_CONSTEL_BOUNDARIES; ++i)
|
|
{
|
|
const constel_boundary_t *b = &ConstelBounds[i];
|
|
if ((b->dec_lo <= b1875.dec) && (b->ra_hi > b1875.ra) && (b->ra_lo <= b1875.ra))
|
|
{
|
|
c = b->index;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (c < 0 || c >= NUM_CONSTELLATIONS)
|
|
return ConstelErr(ASTRO_INTERNAL_ERROR); /* should have been able to find the constellation */
|
|
|
|
constel.status = ASTRO_SUCCESS;
|
|
constel.symbol = ConstelInfo[c].symbol;
|
|
constel.name = ConstelInfo[c].name;
|
|
constel.ra_1875 = b1875.ra;
|
|
constel.dec_1875 = b1875.dec;
|
|
return constel;
|
|
}
|
|
|
|
|
|
static astro_lunar_eclipse_t LunarEclipseError(astro_status_t status)
|
|
{
|
|
astro_lunar_eclipse_t eclipse;
|
|
eclipse.status = status;
|
|
eclipse.kind = ECLIPSE_NONE;
|
|
eclipse.peak = TimeError();
|
|
eclipse.sd_penum = eclipse.sd_partial = eclipse.sd_total = NAN;
|
|
return eclipse;
|
|
}
|
|
|
|
|
|
/** @cond DOXYGEN_SKIP */
|
|
typedef struct
|
|
{
|
|
astro_status_t status;
|
|
astro_time_t time;
|
|
double u; /* dot product of (heliocentric earth) and (geocentric moon): defines the shadow plane where the Moon is */
|
|
double r; /* km distance between center of Moon/Earth (shaded body) and the line passing through the centers of the Sun and Earth/Moon (casting body). */
|
|
double k; /* umbra radius in km, at the shadow plane */
|
|
double p; /* penumbra radius in km, at the shadow plane */
|
|
astro_vector_t target; /* coordinates of target body relative to shadow-casting body at 'time' */
|
|
astro_vector_t dir; /* heliocentric coordinates of shadow-casting body at 'time' */
|
|
}
|
|
shadow_t; /* Represents alignment of the Moon/Earth with the Earth's/Moon's shadow, for finding eclipses. */
|
|
|
|
typedef struct
|
|
{
|
|
double radius_limit;
|
|
double direction;
|
|
}
|
|
shadow_context_t;
|
|
/** @endcond */
|
|
|
|
|
|
static shadow_t ShadowError(astro_status_t status)
|
|
{
|
|
shadow_t shadow;
|
|
memset(&shadow, 0, sizeof(shadow));
|
|
shadow.status = status;
|
|
return shadow;
|
|
}
|
|
|
|
|
|
static shadow_t CalcShadow(
|
|
double body_radius_km,
|
|
astro_time_t time,
|
|
astro_vector_t target,
|
|
astro_vector_t dir)
|
|
{
|
|
double dx, dy, dz;
|
|
shadow_t shadow;
|
|
|
|
shadow.target = target;
|
|
shadow.dir = dir;
|
|
|
|
shadow.u = (dir.x*target.x + dir.y*target.y + dir.z*target.z) / (dir.x*dir.x + dir.y*dir.y + dir.z*dir.z);
|
|
|
|
dx = (shadow.u * dir.x) - target.x;
|
|
dy = (shadow.u * dir.y) - target.y;
|
|
dz = (shadow.u * dir.z) - target.z;
|
|
shadow.r = KM_PER_AU * sqrt(dx*dx + dy*dy + dz*dz);
|
|
|
|
shadow.k = +SUN_RADIUS_KM - (1.0 + shadow.u)*(SUN_RADIUS_KM - body_radius_km);
|
|
shadow.p = -SUN_RADIUS_KM + (1.0 + shadow.u)*(SUN_RADIUS_KM + body_radius_km);
|
|
shadow.status = ASTRO_SUCCESS;
|
|
shadow.time = time;
|
|
|
|
return shadow;
|
|
}
|
|
|
|
|
|
static shadow_t PlanetShadow(astro_body_t body, double planet_radius_km, astro_time_t time)
|
|
{
|
|
astro_vector_t e, p, g;
|
|
|
|
/* Calculate light-travel-corrected vector from Earth to planet. */
|
|
g = Astronomy_GeoVector(body, time, NO_ABERRATION);
|
|
if (g.status != ASTRO_SUCCESS)
|
|
return ShadowError(g.status);
|
|
|
|
/* Calculate light-travel-corrected vector from Earth to Sun. */
|
|
e = Astronomy_GeoVector(BODY_SUN, time, NO_ABERRATION);
|
|
if (e.status != ASTRO_SUCCESS)
|
|
return ShadowError(e.status);
|
|
|
|
/* Deduce light-travel-corrected vector from Sun to planet. */
|
|
p.t = time;
|
|
p.x = g.x - e.x;
|
|
p.y = g.y - e.y;
|
|
p.z = g.z - e.z;
|
|
|
|
/* Calcluate Earth's position from the planet's point of view. */
|
|
e.x = -g.x;
|
|
e.y = -g.y;
|
|
e.z = -g.z;
|
|
|
|
return CalcShadow(planet_radius_km, time, e, p);
|
|
}
|
|
|
|
|
|
static shadow_t EarthShadow(astro_time_t time)
|
|
{
|
|
/* This function helps find when the Earth's shadow falls upon the Moon. */
|
|
astro_vector_t e, m;
|
|
|
|
e = CalcEarth(time); /* This function never fails; no need to check return value */
|
|
m = Astronomy_GeoMoon(time); /* This function never fails; no need to check return value */
|
|
|
|
return CalcShadow(EARTH_ECLIPSE_RADIUS_KM, time, m, e);
|
|
}
|
|
|
|
|
|
static shadow_t MoonShadow(astro_time_t time)
|
|
{
|
|
/* This function helps find when the Moon's shadow falls upon the Earth. */
|
|
|
|
astro_vector_t h, e, m;
|
|
|
|
/*
|
|
This is a variation on the logic in EarthShadow().
|
|
Instead of a heliocentric Earth and a geocentric Moon,
|
|
we want a heliocentric Moon and a lunacentric Earth.
|
|
*/
|
|
|
|
h = CalcEarth(time); /* heliocentric Earth */
|
|
m = Astronomy_GeoMoon(time); /* geocentric Moon */
|
|
|
|
/* Calculate lunacentric Earth. */
|
|
e.status = m.status;
|
|
e.x = -m.x;
|
|
e.y = -m.y;
|
|
e.z = -m.z;
|
|
e.t = m.t;
|
|
|
|
/* Convert geocentric moon to heliocentric Moon. */
|
|
m.x += h.x;
|
|
m.y += h.y;
|
|
m.z += h.z;
|
|
|
|
return CalcShadow(MOON_MEAN_RADIUS_KM, time, e, m);
|
|
}
|
|
|
|
|
|
/** @cond DOXYGEN_SKIP */
|
|
typedef shadow_t (* shadow_func_t) (astro_time_t time);
|
|
/** @endcond */
|
|
|
|
|
|
static astro_func_result_t shadow_distance_slope(void *context, astro_time_t time)
|
|
{
|
|
const double dt = 1.0 / 86400.0;
|
|
astro_time_t t1, t2;
|
|
astro_func_result_t result;
|
|
shadow_t shadow1, shadow2;
|
|
shadow_func_t shadowfunc = context;
|
|
|
|
t1 = Astronomy_AddDays(time, -dt);
|
|
t2 = Astronomy_AddDays(time, +dt);
|
|
|
|
shadow1 = shadowfunc(t1);
|
|
if (shadow1.status != ASTRO_SUCCESS)
|
|
return FuncError(shadow1.status);
|
|
|
|
shadow2 = shadowfunc(t2);
|
|
if (shadow2.status != ASTRO_SUCCESS)
|
|
return FuncError(shadow2.status);
|
|
|
|
result.value = (shadow2.r - shadow1.r) / dt;
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
|
|
static shadow_t PeakEarthShadow(astro_time_t search_center_time)
|
|
{
|
|
/* Search for when the Earth's shadow axis is closest to the center of the Moon. */
|
|
|
|
astro_time_t t1, t2;
|
|
astro_search_result_t result;
|
|
const double window = 0.03; /* days before/after full moon to search for minimum shadow distance */
|
|
|
|
t1 = Astronomy_AddDays(search_center_time, -window);
|
|
t2 = Astronomy_AddDays(search_center_time, +window);
|
|
|
|
result = Astronomy_Search(shadow_distance_slope, EarthShadow, t1, t2, 1.0);
|
|
if (result.status != ASTRO_SUCCESS)
|
|
return ShadowError(result.status);
|
|
|
|
return EarthShadow(result.time);
|
|
}
|
|
|
|
|
|
static shadow_t PeakMoonShadow(astro_time_t search_center_time)
|
|
{
|
|
/* Search for when the Moon's shadow axis is closest to the center of the Earth. */
|
|
|
|
astro_time_t t1, t2;
|
|
astro_search_result_t result;
|
|
const double window = 0.03; /* days before/after new moon to search for minimum shadow distance */
|
|
|
|
t1 = Astronomy_AddDays(search_center_time, -window);
|
|
t2 = Astronomy_AddDays(search_center_time, +window);
|
|
|
|
result = Astronomy_Search(shadow_distance_slope, MoonShadow, t1, t2, 1.0);
|
|
if (result.status != ASTRO_SUCCESS)
|
|
return ShadowError(result.status);
|
|
|
|
return MoonShadow(result.time);
|
|
}
|
|
|
|
|
|
/** @cond DOXYGEN_SKIP */
|
|
typedef struct
|
|
{
|
|
astro_body_t body;
|
|
double planet_radius_km;
|
|
double direction; /* used for transit start/finish search only */
|
|
}
|
|
planet_shadow_context_t;
|
|
/** @endcond */
|
|
|
|
|
|
static astro_func_result_t planet_shadow_distance_slope(void *context, astro_time_t time)
|
|
{
|
|
const double dt = 1.0 / 86400.0;
|
|
astro_time_t t1, t2;
|
|
astro_func_result_t result;
|
|
shadow_t shadow1, shadow2;
|
|
const planet_shadow_context_t *p = context;
|
|
|
|
t1 = Astronomy_AddDays(time, -dt);
|
|
t2 = Astronomy_AddDays(time, +dt);
|
|
|
|
shadow1 = PlanetShadow(p->body, p->planet_radius_km, t1);
|
|
if (shadow1.status != ASTRO_SUCCESS)
|
|
return FuncError(shadow1.status);
|
|
|
|
shadow2 = PlanetShadow(p->body, p->planet_radius_km, t2);
|
|
if (shadow2.status != ASTRO_SUCCESS)
|
|
return FuncError(shadow2.status);
|
|
|
|
result.value = (shadow2.r - shadow1.r) / dt;
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
|
|
static shadow_t PeakPlanetShadow(astro_body_t body, double planet_radius_km, astro_time_t search_center_time)
|
|
{
|
|
/* Search for when the body's shadow is closest to the center of the Earth. */
|
|
|
|
astro_time_t t1, t2;
|
|
astro_search_result_t result;
|
|
planet_shadow_context_t context;
|
|
const double window = 1.0; /* days before/after inferior conjunction to search for minimum shadow distance */
|
|
|
|
t1 = Astronomy_AddDays(search_center_time, -window);
|
|
t2 = Astronomy_AddDays(search_center_time, +window);
|
|
|
|
context.body = body;
|
|
context.planet_radius_km = planet_radius_km;
|
|
context.direction = 0.0; /* not used in this search */
|
|
|
|
result = Astronomy_Search(planet_shadow_distance_slope, &context, t1, t2, 1.0);
|
|
if (result.status != ASTRO_SUCCESS)
|
|
return ShadowError(result.status);
|
|
|
|
return PlanetShadow(body, planet_radius_km, result.time);
|
|
}
|
|
|
|
|
|
static astro_func_result_t shadow_distance(void *context, astro_time_t time)
|
|
{
|
|
astro_func_result_t result;
|
|
const shadow_context_t *p = context;
|
|
shadow_t shadow = EarthShadow(time);
|
|
if (shadow.status != ASTRO_SUCCESS)
|
|
return FuncError(shadow.status);
|
|
|
|
result.value = p->direction * (shadow.r - p->radius_limit);
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
|
|
static double ShadowSemiDurationMinutes(astro_time_t center_time, double radius_limit, double window_minutes)
|
|
{
|
|
/* Search backwards and forwards from the center time until shadow axis distance crosses radius limit. */
|
|
double window = window_minutes / (24.0 * 60.0);
|
|
shadow_context_t context;
|
|
astro_search_result_t s1, s2;
|
|
astro_time_t before, after;
|
|
|
|
before = Astronomy_AddDays(center_time, -window);
|
|
after = Astronomy_AddDays(center_time, +window);
|
|
|
|
context.radius_limit = radius_limit;
|
|
context.direction = -1.0;
|
|
s1 = Astronomy_Search(shadow_distance, &context, before, center_time, 1.0);
|
|
|
|
context.direction = +1.0;
|
|
s2 = Astronomy_Search(shadow_distance, &context, center_time, after, 1.0);
|
|
|
|
if (s1.status != ASTRO_SUCCESS || s2.status != ASTRO_SUCCESS)
|
|
return -1.0; /* something went wrong! */
|
|
|
|
return (s2.time.ut - s1.time.ut) * ((24.0 * 60.0) / 2.0); /* convert days to minutes and average the semi-durations. */
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Searches for a lunar eclipse.
|
|
*
|
|
* This function finds the first lunar eclipse that occurs after `startTime`.
|
|
* A lunar eclipse may be penumbral, partial, or total.
|
|
* See #astro_lunar_eclipse_t for more information.
|
|
* To find a series of lunar eclipses, call this function once,
|
|
* then keep calling #Astronomy_NextLunarEclipse as many times as desired,
|
|
* passing in the `peak` value returned from the previous call.
|
|
*
|
|
* @param startTime
|
|
* The date and time for starting the search for a lunar eclipse.
|
|
*
|
|
* @return
|
|
* If successful, the `status` field in the returned structure will contain `ASTRO_SUCCESS`
|
|
* and the remaining structure fields will be valid.
|
|
* Any other value indicates an error.
|
|
*/
|
|
astro_lunar_eclipse_t Astronomy_SearchLunarEclipse(astro_time_t startTime)
|
|
{
|
|
const double PruneLatitude = 1.8; /* full Moon's ecliptic latitude above which eclipse is impossible */
|
|
astro_time_t fmtime;
|
|
astro_lunar_eclipse_t eclipse;
|
|
astro_search_result_t fullmoon;
|
|
shadow_t shadow;
|
|
int fmcount;
|
|
double eclip_lat, eclip_lon, distance;
|
|
|
|
/* Iterate through consecutive full moons until we find any kind of lunar eclipse. */
|
|
fmtime = startTime;
|
|
for (fmcount=0; fmcount < 12; ++fmcount)
|
|
{
|
|
/* Search for the next full moon. Any eclipse will be near it. */
|
|
fullmoon = Astronomy_SearchMoonPhase(180.0, fmtime, 40.0);
|
|
if (fullmoon.status != ASTRO_SUCCESS)
|
|
return LunarEclipseError(fullmoon.status);
|
|
|
|
/* Pruning: if the full Moon's ecliptic latitude is too large, a lunar eclipse is not possible. */
|
|
CalcMoon(fullmoon.time.tt / 36525.0, &eclip_lon, &eclip_lat, &distance);
|
|
if (RAD2DEG * fabs(eclip_lat) < PruneLatitude)
|
|
{
|
|
/* Search near the full moon for the time when the center of the Moon */
|
|
/* is closest to the line passing through the centers of the Sun and Earth. */
|
|
shadow = PeakEarthShadow(fullmoon.time);
|
|
if (shadow.status != ASTRO_SUCCESS)
|
|
return LunarEclipseError(shadow.status);
|
|
|
|
if (shadow.r < shadow.p + MOON_MEAN_RADIUS_KM)
|
|
{
|
|
/* This is at least a penumbral eclipse. We will return a result. */
|
|
eclipse.status = ASTRO_SUCCESS;
|
|
eclipse.kind = ECLIPSE_PENUMBRAL;
|
|
eclipse.peak = shadow.time;
|
|
eclipse.sd_total = 0.0;
|
|
eclipse.sd_partial = 0.0;
|
|
eclipse.sd_penum = ShadowSemiDurationMinutes(shadow.time, shadow.p + MOON_MEAN_RADIUS_KM, 200.0);
|
|
if (eclipse.sd_penum <= 0.0)
|
|
return LunarEclipseError(ASTRO_SEARCH_FAILURE);
|
|
|
|
if (shadow.r < shadow.k + MOON_MEAN_RADIUS_KM)
|
|
{
|
|
/* This is at least a partial eclipse. */
|
|
eclipse.kind = ECLIPSE_PARTIAL;
|
|
eclipse.sd_partial = ShadowSemiDurationMinutes(shadow.time, shadow.k + MOON_MEAN_RADIUS_KM, eclipse.sd_penum);
|
|
if (eclipse.sd_partial <= 0.0)
|
|
return LunarEclipseError(ASTRO_SEARCH_FAILURE);
|
|
|
|
if (shadow.r + MOON_MEAN_RADIUS_KM < shadow.k)
|
|
{
|
|
/* This is a total eclipse. */
|
|
eclipse.kind = ECLIPSE_TOTAL;
|
|
eclipse.sd_total = ShadowSemiDurationMinutes(shadow.time, shadow.k - MOON_MEAN_RADIUS_KM, eclipse.sd_partial);
|
|
if (eclipse.sd_total <= 0.0)
|
|
return LunarEclipseError(ASTRO_SEARCH_FAILURE);
|
|
}
|
|
}
|
|
return eclipse;
|
|
}
|
|
}
|
|
|
|
/* We didn't find an eclipse on this full moon, so search for the next one. */
|
|
fmtime = Astronomy_AddDays(fullmoon.time, 10.0);
|
|
}
|
|
|
|
/* Safety valve to prevent infinite loop. */
|
|
/* This should never happen, because at least 2 lunar eclipses happen per year. */
|
|
return LunarEclipseError(ASTRO_INTERNAL_ERROR);
|
|
}
|
|
|
|
/**
|
|
* @brief Searches for the next lunar eclipse in a series.
|
|
*
|
|
* After using #Astronomy_SearchLunarEclipse to find the first lunar eclipse
|
|
* in a series, you can call this function to find the next consecutive lunar eclipse.
|
|
* Pass in the `peak` value from the #astro_lunar_eclipse_t returned by the
|
|
* previous call to `Astronomy_SearchLunarEclipse` or `Astronomy_NextLunarEclipse`
|
|
* to find the next lunar eclipse.
|
|
*
|
|
* @param prevEclipseTime
|
|
* A date and time near a full moon. Lunar eclipse search will start at the next full moon.
|
|
*
|
|
* @return
|
|
* If successful, the `status` field in the returned structure will contain `ASTRO_SUCCESS`
|
|
* and the remaining structure fields will be valid.
|
|
* Any other value indicates an error.
|
|
*/
|
|
astro_lunar_eclipse_t Astronomy_NextLunarEclipse(astro_time_t prevEclipseTime)
|
|
{
|
|
astro_time_t startTime = Astronomy_AddDays(prevEclipseTime, 10.0);
|
|
return Astronomy_SearchLunarEclipse(startTime);
|
|
}
|
|
|
|
|
|
static astro_global_solar_eclipse_t GlobalSolarEclipseError(astro_status_t status)
|
|
{
|
|
astro_global_solar_eclipse_t eclipse;
|
|
|
|
eclipse.status = status;
|
|
eclipse.kind = ECLIPSE_NONE;
|
|
eclipse.peak = TimeError();
|
|
eclipse.distance = eclipse.latitude = eclipse.longitude = NAN;
|
|
|
|
return eclipse;
|
|
}
|
|
|
|
/* The umbra radius tells us what kind of eclipse the observer sees. */
|
|
/* If the umbra radius is positive, this is a total eclipse. Otherwise, it's annular. */
|
|
/* HACK: I added a tiny bias (14 meters) to match Espenak test data. */
|
|
#define EclipseKindFromUmbra(k) (((k) > 0.014) ? ECLIPSE_TOTAL : ECLIPSE_ANNULAR)
|
|
|
|
static astro_global_solar_eclipse_t GeoidIntersect(shadow_t shadow)
|
|
{
|
|
astro_global_solar_eclipse_t eclipse;
|
|
astro_rotation_t rot, inv;
|
|
astro_vector_t v, e, o;
|
|
shadow_t surface;
|
|
double A, B, C, radic, u, R;
|
|
double px, py, pz, proj;
|
|
double gast;
|
|
|
|
eclipse.status = ASTRO_SUCCESS;
|
|
eclipse.kind = ECLIPSE_PARTIAL;
|
|
eclipse.peak = shadow.time;
|
|
eclipse.distance = shadow.r;
|
|
eclipse.latitude = eclipse.longitude = NAN;
|
|
|
|
/*
|
|
We want to calculate the intersection of the shadow axis with the Earth's geoid.
|
|
First we must convert EQJ (equator of J2000) coordinates to EQD (equator of date)
|
|
coordinates that are perfectly aligned with the Earth's equator at this
|
|
moment in time.
|
|
*/
|
|
rot = Astronomy_Rotation_EQJ_EQD(shadow.time);
|
|
if (rot.status != ASTRO_SUCCESS)
|
|
return GlobalSolarEclipseError(rot.status);
|
|
|
|
v = Astronomy_RotateVector(rot, shadow.dir); /* shadow-axis vector in equator-of-date coordinates */
|
|
if (v.status != ASTRO_SUCCESS)
|
|
return GlobalSolarEclipseError(v.status);
|
|
|
|
e = Astronomy_RotateVector(rot, shadow.target); /* lunacentric Earth in equator-of-date coordinates */
|
|
if (e.status != ASTRO_SUCCESS)
|
|
return GlobalSolarEclipseError(e.status);
|
|
|
|
/*
|
|
Convert all distances from AU to km.
|
|
But dilate the z-coordinates so that the Earth becomes a perfect sphere.
|
|
Then find the intersection of the vector with the sphere.
|
|
See p 184 in Montenbruck & Pfleger's "Astronomy on the Personal Computer", second edition.
|
|
*/
|
|
v.x *= KM_PER_AU;
|
|
v.y *= KM_PER_AU;
|
|
v.z *= KM_PER_AU / EARTH_FLATTENING;
|
|
|
|
e.x *= KM_PER_AU;
|
|
e.y *= KM_PER_AU;
|
|
e.z *= KM_PER_AU / EARTH_FLATTENING;
|
|
|
|
/*
|
|
Solve the quadratic equation that finds whether and where
|
|
the shadow axis intersects with the Earth in the dilated coordinate system.
|
|
*/
|
|
R = EARTH_EQUATORIAL_RADIUS_KM;
|
|
A = v.x*v.x + v.y*v.y + v.z*v.z;
|
|
B = -2.0 * (v.x*e.x + v.y*e.y + v.z*e.z);
|
|
C = (e.x*e.x + e.y*e.y + e.z*e.z) - R*R;
|
|
radic = B*B - 4*A*C;
|
|
|
|
if (radic > 0.0)
|
|
{
|
|
/* Calculate the closer of the two intersection points. */
|
|
/* This will be on the day side of the Earth. */
|
|
u = (-B - sqrt(radic)) / (2 * A);
|
|
|
|
/* Convert lunacentric dilated coordinates to geocentric coordinates. */
|
|
px = u*v.x - e.x;
|
|
py = u*v.y - e.y;
|
|
pz = (u*v.z - e.z) * EARTH_FLATTENING;
|
|
|
|
/* Convert cartesian coordinates into geodetic latitude/longitude. */
|
|
proj = sqrt(px*px + py*py) * (EARTH_FLATTENING * EARTH_FLATTENING);
|
|
if (proj == 0.0)
|
|
eclipse.latitude = (pz > 0.0) ? +90.0 : -90.0;
|
|
else
|
|
eclipse.latitude = RAD2DEG * atan(pz / proj);
|
|
|
|
/* Adjust longitude for Earth's rotation at the given UT. */
|
|
gast = sidereal_time(&eclipse.peak);
|
|
eclipse.longitude = fmod((RAD2DEG*atan2(py, px)) - (15*gast), 360.0);
|
|
if (eclipse.longitude <= -180.0)
|
|
eclipse.longitude += 360.0;
|
|
else if (eclipse.longitude > +180.0)
|
|
eclipse.longitude -= 360.0;
|
|
|
|
/* We want to determine whether the observer sees a total eclipse or an annular eclipse. */
|
|
/* We need to perform a series of vector calculations... */
|
|
/* Calculate the inverse rotation matrix, so we can convert EQD to EQJ. */
|
|
inv = Astronomy_InverseRotation(rot);
|
|
if (inv.status != ASTRO_SUCCESS)
|
|
return GlobalSolarEclipseError(inv.status);
|
|
|
|
/* Put the EQD geocentric coordinates of the observer into the vector 'o'. */
|
|
/* Also convert back from kilometers to astronomical units. */
|
|
o.status = ASTRO_SUCCESS;
|
|
o.t = shadow.time;
|
|
o.x = px / KM_PER_AU;
|
|
o.y = py / KM_PER_AU;
|
|
o.z = pz / KM_PER_AU;
|
|
|
|
/* Rotate the observer's geocentric EQD back to the EQJ system. */
|
|
o = Astronomy_RotateVector(inv, o);
|
|
|
|
/* Convert geocentric vector to lunacentric vector. */
|
|
o.x += shadow.target.x;
|
|
o.y += shadow.target.y;
|
|
o.z += shadow.target.z;
|
|
|
|
/* Recalculate the shadow using a vector from the Moon's center toward the observer. */
|
|
surface = CalcShadow(MOON_POLAR_RADIUS_KM, shadow.time, o, shadow.dir);
|
|
|
|
/* If we did everything right, the shadow distance should be very close to zero. */
|
|
/* That's because we already determined the observer 'o' is on the shadow axis! */
|
|
if (surface.r > 1.0e-9 || surface.r < 0.0)
|
|
return GlobalSolarEclipseError(ASTRO_INTERNAL_ERROR);
|
|
|
|
eclipse.kind = EclipseKindFromUmbra(surface.k);
|
|
}
|
|
|
|
return eclipse;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Searches for a solar eclipse visible anywhere on the Earth's surface.
|
|
*
|
|
* This function finds the first solar eclipse that occurs after `startTime`.
|
|
* A solar eclipse may be partial, annular, or total.
|
|
* See #astro_global_solar_eclipse_t for more information.
|
|
* To find a series of solar eclipses, call this function once,
|
|
* then keep calling #Astronomy_NextGlobalSolarEclipse as many times as desired,
|
|
* passing in the `peak` value returned from the previous call.
|
|
*
|
|
* @param startTime
|
|
* The date and time for starting the search for a solar eclipse.
|
|
*
|
|
* @return
|
|
* If successful, the `status` field in the returned structure will contain `ASTRO_SUCCESS`
|
|
* and the remaining structure fields are as described in #astro_global_solar_eclipse_t.
|
|
* Any other value indicates an error.
|
|
*/
|
|
astro_global_solar_eclipse_t Astronomy_SearchGlobalSolarEclipse(astro_time_t startTime)
|
|
{
|
|
const double PruneLatitude = 1.8; /* Moon's ecliptic latitude beyond which eclipse is impossible */
|
|
astro_time_t nmtime;
|
|
astro_search_result_t newmoon;
|
|
shadow_t shadow;
|
|
int nmcount;
|
|
double eclip_lat, eclip_lon, distance;
|
|
|
|
/* Iterate through consecutive new moons until we find a solar eclipse visible somewhere on Earth. */
|
|
nmtime = startTime;
|
|
for (nmcount=0; nmcount < 12; ++nmcount)
|
|
{
|
|
/* Search for the next new moon. Any eclipse will be near it. */
|
|
newmoon = Astronomy_SearchMoonPhase(0.0, nmtime, 40.0);
|
|
if (newmoon.status != ASTRO_SUCCESS)
|
|
return GlobalSolarEclipseError(newmoon.status);
|
|
|
|
/* Pruning: if the new moon's ecliptic latitude is too large, a solar eclipse is not possible. */
|
|
CalcMoon(newmoon.time.tt / 36525.0, &eclip_lon, &eclip_lat, &distance);
|
|
if (RAD2DEG * fabs(eclip_lat) < PruneLatitude)
|
|
{
|
|
/* Search near the new moon for the time when the center of the Earth */
|
|
/* is closest to the line passing through the centers of the Sun and Moon. */
|
|
shadow = PeakMoonShadow(newmoon.time);
|
|
if (shadow.status != ASTRO_SUCCESS)
|
|
return GlobalSolarEclipseError(shadow.status);
|
|
|
|
if (shadow.r < shadow.p + EARTH_MEAN_RADIUS_KM)
|
|
{
|
|
/* This is at least a partial solar eclipse visible somewhere on Earth. */
|
|
/* Try to find an intersection between the shadow axis and the Earth's oblate geoid. */
|
|
return GeoidIntersect(shadow);
|
|
}
|
|
}
|
|
|
|
/* We didn't find an eclipse on this new moon, so search for the next one. */
|
|
nmtime = Astronomy_AddDays(newmoon.time, 10.0);
|
|
}
|
|
|
|
/* Safety valve to prevent infinite loop. */
|
|
/* This should never happen, because at least 2 solar eclipses happen per year. */
|
|
return GlobalSolarEclipseError(ASTRO_INTERNAL_ERROR);
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Searches for the next global solar eclipse in a series.
|
|
*
|
|
* After using #Astronomy_SearchGlobalSolarEclipse to find the first solar eclipse
|
|
* in a series, you can call this function to find the next consecutive solar eclipse.
|
|
* Pass in the `peak` value from the #astro_global_solar_eclipse_t returned by the
|
|
* previous call to `Astronomy_SearchGlobalSolarEclipse` or `Astronomy_NextGlobalSolarEclipse`
|
|
* to find the next solar eclipse.
|
|
*
|
|
* @param prevEclipseTime
|
|
* A date and time near a new moon. Solar eclipse search will start at the next new moon.
|
|
*
|
|
* @return
|
|
* If successful, the `status` field in the returned structure will contain `ASTRO_SUCCESS`
|
|
* and the remaining structure fields are as described in #astro_global_solar_eclipse_t.
|
|
* Any other value indicates an error.
|
|
*/
|
|
astro_global_solar_eclipse_t Astronomy_NextGlobalSolarEclipse(astro_time_t prevEclipseTime)
|
|
{
|
|
astro_time_t startTime = Astronomy_AddDays(prevEclipseTime, 10.0);
|
|
return Astronomy_SearchGlobalSolarEclipse(startTime);
|
|
}
|
|
|
|
|
|
static astro_eclipse_event_t EclipseEventError(void)
|
|
{
|
|
astro_eclipse_event_t evt;
|
|
evt.time = TimeError();
|
|
evt.altitude = NAN;
|
|
return evt;
|
|
}
|
|
|
|
|
|
static astro_local_solar_eclipse_t LocalSolarEclipseError(astro_status_t status)
|
|
{
|
|
astro_local_solar_eclipse_t eclipse;
|
|
|
|
eclipse.status = status;
|
|
eclipse.kind = ECLIPSE_NONE;
|
|
|
|
eclipse.partial_begin = EclipseEventError();
|
|
eclipse.total_begin = EclipseEventError();
|
|
eclipse.peak = EclipseEventError();
|
|
eclipse.total_end = EclipseEventError();
|
|
eclipse.partial_end = EclipseEventError();
|
|
|
|
return eclipse;
|
|
}
|
|
|
|
|
|
static shadow_t LocalMoonShadow(astro_time_t time, astro_observer_t observer)
|
|
{
|
|
astro_vector_t h, o, m;
|
|
double pos[3];
|
|
|
|
/* Calculate observer's geocentric position. */
|
|
/* For efficiency, do this first, to populate the earth rotation parameters in 'time'. */
|
|
/* That way they can be recycled instead of recalculated. */
|
|
geo_pos(&time, observer, pos);
|
|
|
|
h = CalcEarth(time); /* heliocentric Earth */
|
|
m = Astronomy_GeoMoon(time); /* geocentric Moon */
|
|
|
|
/* Calculate lunacentric location of an observer on the Earth's surface. */
|
|
o.status = m.status;
|
|
o.x = pos[0] - m.x;
|
|
o.y = pos[1] - m.y;
|
|
o.z = pos[2] - m.z;
|
|
o.t = m.t;
|
|
|
|
/* Convert geocentric moon to heliocentric Moon. */
|
|
m.x += h.x;
|
|
m.y += h.y;
|
|
m.z += h.z;
|
|
|
|
return CalcShadow(MOON_MEAN_RADIUS_KM, time, o, m);
|
|
}
|
|
|
|
|
|
static astro_func_result_t local_shadow_distance_slope(void *context, astro_time_t time)
|
|
{
|
|
const double dt = 1.0 / 86400.0;
|
|
astro_time_t t1, t2;
|
|
astro_func_result_t result;
|
|
shadow_t shadow1, shadow2;
|
|
const astro_observer_t *observer = context;
|
|
|
|
t1 = Astronomy_AddDays(time, -dt);
|
|
t2 = Astronomy_AddDays(time, +dt);
|
|
|
|
shadow1 = LocalMoonShadow(t1, *observer);
|
|
if (shadow1.status != ASTRO_SUCCESS)
|
|
return FuncError(shadow1.status);
|
|
|
|
shadow2 = LocalMoonShadow(t2, *observer);
|
|
if (shadow2.status != ASTRO_SUCCESS)
|
|
return FuncError(shadow2.status);
|
|
|
|
result.value = (shadow2.r - shadow1.r) / dt;
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
|
|
static shadow_t PeakLocalMoonShadow(astro_time_t search_center_time, astro_observer_t observer)
|
|
{
|
|
astro_time_t t1, t2;
|
|
astro_search_result_t result;
|
|
const double window = 0.2;
|
|
|
|
/*
|
|
Search for the time near search_center_time that the Moon's shadow comes
|
|
closest to the given observer.
|
|
*/
|
|
|
|
t1 = Astronomy_AddDays(search_center_time, -window);
|
|
t2 = Astronomy_AddDays(search_center_time, +window);
|
|
|
|
result = Astronomy_Search(local_shadow_distance_slope, &observer, t1, t2, 1.0);
|
|
if (result.status != ASTRO_SUCCESS)
|
|
return ShadowError(result.status);
|
|
|
|
return LocalMoonShadow(result.time, observer);
|
|
}
|
|
|
|
|
|
static double local_partial_distance(const shadow_t *shadow)
|
|
{
|
|
return shadow->p - shadow->r;
|
|
}
|
|
|
|
static double local_total_distance(const shadow_t *shadow)
|
|
{
|
|
/* Must take the absolute value of the umbra radius 'k' */
|
|
/* because it can be negative for an annular eclipse. */
|
|
return fabs(shadow->k) - shadow->r;
|
|
}
|
|
|
|
/** @cond DOXYGEN_SKIP */
|
|
typedef double (* local_distance_func) (const shadow_t *shadow);
|
|
|
|
typedef struct
|
|
{
|
|
local_distance_func func;
|
|
double direction;
|
|
astro_observer_t observer;
|
|
}
|
|
eclipse_transition_t;
|
|
/* @endcond */
|
|
|
|
|
|
static astro_func_result_t local_eclipse_func(void *context, astro_time_t time)
|
|
{
|
|
const eclipse_transition_t *trans = context;
|
|
shadow_t shadow;
|
|
astro_func_result_t result;
|
|
|
|
shadow = LocalMoonShadow(time, trans->observer);
|
|
if (shadow.status != ASTRO_SUCCESS)
|
|
return FuncError(shadow.status);
|
|
|
|
result.value = trans->direction * trans->func(&shadow);
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
|
|
astro_func_result_t SunAltitude(
|
|
astro_time_t time,
|
|
astro_observer_t observer)
|
|
{
|
|
astro_equatorial_t equ;
|
|
astro_horizon_t hor;
|
|
astro_func_result_t result;
|
|
|
|
equ = Astronomy_Equator(BODY_SUN, &time, observer, EQUATOR_OF_DATE, ABERRATION);
|
|
if (equ.status != ASTRO_SUCCESS)
|
|
return FuncError(equ.status);
|
|
|
|
hor = Astronomy_Horizon(&time, observer, equ.ra, equ.dec, REFRACTION_NORMAL);
|
|
result.value = hor.altitude;
|
|
result.status = ASTRO_SUCCESS;
|
|
return result;
|
|
}
|
|
|
|
|
|
static astro_status_t CalcEvent(
|
|
astro_observer_t observer,
|
|
astro_time_t time,
|
|
astro_eclipse_event_t *evt)
|
|
{
|
|
astro_func_result_t result;
|
|
|
|
result = SunAltitude(time, observer);
|
|
if (result.status != ASTRO_SUCCESS)
|
|
{
|
|
evt->time = TimeError();
|
|
evt->altitude = NAN;
|
|
return result.status;
|
|
}
|
|
|
|
evt->time = time;
|
|
evt->altitude = result.value;
|
|
return ASTRO_SUCCESS;
|
|
}
|
|
|
|
|
|
static astro_status_t LocalEclipseTransition(
|
|
astro_observer_t observer,
|
|
double direction,
|
|
local_distance_func func,
|
|
astro_time_t t1,
|
|
astro_time_t t2,
|
|
astro_eclipse_event_t *evt)
|
|
{
|
|
eclipse_transition_t trans;
|
|
astro_search_result_t search;
|
|
|
|
trans.func = func;
|
|
trans.direction = direction;
|
|
trans.observer = observer;
|
|
|
|
search = Astronomy_Search(local_eclipse_func, &trans, t1, t2, 1.0);
|
|
if (search.status != ASTRO_SUCCESS)
|
|
{
|
|
evt->time = TimeError();
|
|
evt->altitude = NAN;
|
|
return search.status;
|
|
}
|
|
|
|
return CalcEvent(observer, search.time, evt);
|
|
}
|
|
|
|
|
|
static astro_local_solar_eclipse_t LocalEclipse(
|
|
shadow_t shadow,
|
|
astro_observer_t observer)
|
|
{
|
|
const double PARTIAL_WINDOW = 0.2;
|
|
const double TOTAL_WINDOW = 0.01;
|
|
astro_local_solar_eclipse_t eclipse;
|
|
astro_time_t t1, t2;
|
|
astro_status_t status;
|
|
|
|
status = CalcEvent(observer, shadow.time, &eclipse.peak);
|
|
if (status != ASTRO_SUCCESS)
|
|
return LocalSolarEclipseError(status);
|
|
|
|
t1 = Astronomy_AddDays(shadow.time, -PARTIAL_WINDOW);
|
|
t2 = Astronomy_AddDays(shadow.time, +PARTIAL_WINDOW);
|
|
|
|
status = LocalEclipseTransition(observer, +1.0, local_partial_distance, t1, shadow.time, &eclipse.partial_begin);
|
|
if (status != ASTRO_SUCCESS)
|
|
return LocalSolarEclipseError(status);
|
|
|
|
status = LocalEclipseTransition(observer, -1.0, local_partial_distance, shadow.time, t2, &eclipse.partial_end);
|
|
if (status != ASTRO_SUCCESS)
|
|
return LocalSolarEclipseError(status);
|
|
|
|
if (shadow.r < fabs(shadow.k)) /* take absolute value of 'k' to handle annular eclipses too. */
|
|
{
|
|
t1 = Astronomy_AddDays(shadow.time, -TOTAL_WINDOW);
|
|
t2 = Astronomy_AddDays(shadow.time, +TOTAL_WINDOW);
|
|
|
|
status = LocalEclipseTransition(observer, +1.0, local_total_distance, t1, shadow.time, &eclipse.total_begin);
|
|
if (status != ASTRO_SUCCESS)
|
|
return LocalSolarEclipseError(status);
|
|
|
|
status = LocalEclipseTransition(observer, -1.0, local_total_distance, shadow.time, t2, &eclipse.total_end);
|
|
if (status != ASTRO_SUCCESS)
|
|
return LocalSolarEclipseError(status);
|
|
|
|
eclipse.kind = EclipseKindFromUmbra(shadow.k);
|
|
}
|
|
else
|
|
{
|
|
eclipse.total_begin = eclipse.total_end = EclipseEventError();
|
|
eclipse.kind = ECLIPSE_PARTIAL;
|
|
}
|
|
|
|
eclipse.status = ASTRO_SUCCESS;
|
|
return eclipse;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Searches for a solar eclipse visible at a specific location on the Earth's surface.
|
|
*
|
|
* This function finds the first solar eclipse that occurs after `startTime`.
|
|
* A solar eclipse may be partial, annular, or total.
|
|
* See #astro_local_solar_eclipse_t for more information.
|
|
* To find a series of solar eclipses, call this function once,
|
|
* then keep calling #Astronomy_NextLocalSolarEclipse as many times as desired,
|
|
* passing in the `peak` value returned from the previous call.
|
|
*
|
|
* IMPORTANT: An eclipse reported by this function might be partly or
|
|
* completely invisible to the observer due to the time of day.
|
|
*
|
|
* @param startTime
|
|
* The date and time for starting the search for a solar eclipse.
|
|
*
|
|
* @param observer
|
|
* The geographic location of the observer.
|
|
*
|
|
* @return
|
|
* If successful, the `status` field in the returned structure will contain `ASTRO_SUCCESS`
|
|
* and the remaining structure fields are as described in #astro_local_solar_eclipse_t.
|
|
* Any other value indicates an error.
|
|
*/
|
|
astro_local_solar_eclipse_t Astronomy_SearchLocalSolarEclipse(
|
|
astro_time_t startTime,
|
|
astro_observer_t observer)
|
|
{
|
|
const double PruneLatitude = 1.8; /* Moon's ecliptic latitude beyond which eclipse is impossible */
|
|
astro_time_t nmtime;
|
|
astro_search_result_t newmoon;
|
|
shadow_t shadow;
|
|
double eclip_lat, eclip_lon, distance;
|
|
astro_local_solar_eclipse_t eclipse;
|
|
|
|
/* Iterate through consecutive new moons until we find a solar eclipse visible somewhere on Earth. */
|
|
nmtime = startTime;
|
|
for(;;)
|
|
{
|
|
/* Search for the next new moon. Any eclipse will be near it. */
|
|
newmoon = Astronomy_SearchMoonPhase(0.0, nmtime, 40.0);
|
|
if (newmoon.status != ASTRO_SUCCESS)
|
|
return LocalSolarEclipseError(newmoon.status);
|
|
|
|
/* Pruning: if the new moon's ecliptic latitude is too large, a solar eclipse is not possible. */
|
|
CalcMoon(newmoon.time.tt / 36525.0, &eclip_lon, &eclip_lat, &distance);
|
|
if (RAD2DEG * fabs(eclip_lat) < PruneLatitude)
|
|
{
|
|
/* Search near the new moon for the time when the observer */
|
|
/* is closest to the line passing through the centers of the Sun and Moon. */
|
|
shadow = PeakLocalMoonShadow(newmoon.time, observer);
|
|
if (shadow.status != ASTRO_SUCCESS)
|
|
return LocalSolarEclipseError(shadow.status);
|
|
|
|
if (shadow.r < shadow.p)
|
|
{
|
|
/* This is at least a partial solar eclipse for the observer. */
|
|
eclipse = LocalEclipse(shadow, observer);
|
|
|
|
/* If any error occurs, something is really wrong and we should bail out. */
|
|
if (eclipse.status != ASTRO_SUCCESS)
|
|
return eclipse;
|
|
|
|
/* Ignore any eclipse that happens completely at night. */
|
|
/* More precisely, the center of the Sun must be above the horizon */
|
|
/* at the beginning or the end of the eclipse, or we skip the event. */
|
|
if (eclipse.partial_begin.altitude > 0.0 || eclipse.partial_end.altitude > 0.0)
|
|
return eclipse;
|
|
}
|
|
}
|
|
|
|
/* We didn't find an eclipse on this new moon, so search for the next one. */
|
|
nmtime = Astronomy_AddDays(newmoon.time, 10.0);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Searches for the next local solar eclipse in a series.
|
|
*
|
|
* After using #Astronomy_SearchLocalSolarEclipse to find the first solar eclipse
|
|
* in a series, you can call this function to find the next consecutive solar eclipse.
|
|
* Pass in the `peak` value from the #astro_local_solar_eclipse_t returned by the
|
|
* previous call to `Astronomy_SearchLocalSolarEclipse` or `Astronomy_NextLocalSolarEclipse`
|
|
* to find the next solar eclipse.
|
|
*
|
|
* @param prevEclipseTime
|
|
* A date and time near a new moon. Solar eclipse search will start at the next new moon.
|
|
*
|
|
* @param observer
|
|
* The geographic location of the observer.
|
|
*
|
|
* @return
|
|
* If successful, the `status` field in the returned structure will contain `ASTRO_SUCCESS`
|
|
* and the remaining structure fields are as described in #astro_local_solar_eclipse_t.
|
|
* Any other value indicates an error.
|
|
*/
|
|
astro_local_solar_eclipse_t Astronomy_NextLocalSolarEclipse(
|
|
astro_time_t prevEclipseTime,
|
|
astro_observer_t observer)
|
|
{
|
|
astro_time_t startTime = Astronomy_AddDays(prevEclipseTime, 10.0);
|
|
return Astronomy_SearchLocalSolarEclipse(startTime, observer);
|
|
}
|
|
|
|
|
|
static astro_func_result_t planet_transit_bound(void *context, astro_time_t time)
|
|
{
|
|
shadow_t shadow;
|
|
astro_func_result_t result;
|
|
const planet_shadow_context_t *p = context;
|
|
|
|
shadow = PlanetShadow(p->body, p->planet_radius_km, time);
|
|
if (shadow.status != ASTRO_SUCCESS)
|
|
return FuncError(shadow.status);
|
|
|
|
result.status = ASTRO_SUCCESS;
|
|
result.value = p->direction * (shadow.r - shadow.p);
|
|
return result;
|
|
}
|
|
|
|
|
|
static astro_search_result_t PlanetTransitBoundary(
|
|
astro_body_t body,
|
|
double planet_radius_km,
|
|
astro_time_t t1,
|
|
astro_time_t t2,
|
|
double direction)
|
|
{
|
|
/* Search for the time the planet's penumbra begins/ends making contact with the center of the Earth. */
|
|
planet_shadow_context_t context;
|
|
|
|
context.body = body;
|
|
context.planet_radius_km = planet_radius_km;
|
|
context.direction = direction;
|
|
|
|
return Astronomy_Search(planet_transit_bound, &context, t1, t2, 1.0);
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Searches for the first transit of Mercury or Venus after a given date.
|
|
*
|
|
* Finds the first transit of Mercury or Venus after a specified date.
|
|
* A transit is when an inferior planet passes between the Sun and the Earth
|
|
* so that the silhouette of the planet is visible against the Sun in the background.
|
|
* To continue the search, pass the `finish` time in the returned structure to
|
|
* #Astronomy_NextTransit.
|
|
*
|
|
* @param body
|
|
* The planet whose transit is to be found. Must be `BODY_MERCURY` or `BODY_VENUS`.
|
|
*
|
|
* @param startTime
|
|
* The date and time for starting the search for a transit.
|
|
*
|
|
* @return
|
|
* If successful, the `status` field in the returned structure hold `ASTRO_SUCCESS`
|
|
* and the other fields are as documented in #astro_transit_t.
|
|
* Otherwise, `status` holds an error code and the other structure members are undefined.
|
|
*/
|
|
astro_transit_t Astronomy_SearchTransit(astro_body_t body, astro_time_t startTime)
|
|
{
|
|
astro_time_t search_time;
|
|
astro_transit_t transit;
|
|
astro_search_result_t conj, search;
|
|
astro_angle_result_t conj_separation, min_separation;
|
|
shadow_t shadow;
|
|
double planet_radius_km;
|
|
astro_time_t tx;
|
|
const double threshold_angle = 0.4; /* maximum angular separation to attempt transit calculation */
|
|
const double dt_days = 1.0;
|
|
|
|
/* Validate the planet and find its mean radius. */
|
|
switch (body)
|
|
{
|
|
case BODY_MERCURY: planet_radius_km = 2439.7; break;
|
|
case BODY_VENUS: planet_radius_km = 6051.8; break;
|
|
default:
|
|
return TransitErr(ASTRO_INVALID_BODY);
|
|
}
|
|
|
|
search_time = startTime;
|
|
for(;;)
|
|
{
|
|
/*
|
|
Search for the next inferior conjunction of the given planet.
|
|
This is the next time the Earth and the other planet have the same
|
|
ecliptic longitude as seen from the Sun.
|
|
*/
|
|
conj = Astronomy_SearchRelativeLongitude(body, 0.0, search_time);
|
|
if (conj.status != ASTRO_SUCCESS)
|
|
return TransitErr(conj.status);
|
|
|
|
/* Calculate the angular separation between the body and the Sun at this time. */
|
|
conj_separation = Astronomy_AngleFromSun(body, conj.time);
|
|
if (conj_separation.status != ASTRO_SUCCESS)
|
|
return TransitErr(conj_separation.status);
|
|
|
|
if (conj_separation.angle < threshold_angle)
|
|
{
|
|
/*
|
|
The planet's angular separation from the Sun is small enough
|
|
to consider it a transit candidate.
|
|
Search for the moment when the line passing through the Sun
|
|
and planet are closest to the Earth's center.
|
|
*/
|
|
shadow = PeakPlanetShadow(body, planet_radius_km, conj.time);
|
|
if (shadow.status != ASTRO_SUCCESS)
|
|
return TransitErr(shadow.status);
|
|
|
|
if (shadow.r < shadow.p) /* does the planet's penumbra touch the Earth's center? */
|
|
{
|
|
/* Find the beginning and end of the penumbral contact. */
|
|
tx = Astronomy_AddDays(shadow.time, -dt_days);
|
|
search = PlanetTransitBoundary(body, planet_radius_km, tx, shadow.time, -1.0);
|
|
if (search.status != ASTRO_SUCCESS)
|
|
return TransitErr(search.status);
|
|
transit.start = search.time;
|
|
|
|
tx = Astronomy_AddDays(shadow.time, +dt_days);
|
|
search = PlanetTransitBoundary(body, planet_radius_km, shadow.time, tx, +1.0);
|
|
if (search.status != ASTRO_SUCCESS)
|
|
return TransitErr(search.status);
|
|
transit.finish = search.time;
|
|
transit.status = ASTRO_SUCCESS;
|
|
transit.peak = shadow.time;
|
|
|
|
min_separation = Astronomy_AngleFromSun(body, shadow.time);
|
|
if (min_separation.status != ASTRO_SUCCESS)
|
|
return TransitErr(min_separation.status);
|
|
|
|
transit.separation = 60.0 * min_separation.angle; /* convert degrees to arcminutes */
|
|
return transit;
|
|
}
|
|
}
|
|
|
|
/* This inferior conjunction was not a transit. Try the next inferior conjunction. */
|
|
search_time = Astronomy_AddDays(conj.time, 10.0);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Searches for another transit of Mercury or Venus.
|
|
*
|
|
* After calling #Astronomy_SearchTransit to find a transit of Mercury or Venus,
|
|
* this function finds the next transit after that.
|
|
* Keep calling this function as many times as you want to keep finding more transits.
|
|
*
|
|
* @param body
|
|
* The planet whose transit is to be found. Must be `BODY_MERCURY` or `BODY_VENUS`.
|
|
*
|
|
* @param prevTransitTime
|
|
* A date and time near the previous transit.
|
|
*
|
|
* @return
|
|
* If successful, the `status` field in the returned structure hold `ASTRO_SUCCESS`
|
|
* and the other fields are as documented in #astro_transit_t.
|
|
* Otherwise, `status` holds an error code and the other structure members are undefined.
|
|
*/
|
|
astro_transit_t Astronomy_NextTransit(astro_body_t body, astro_time_t prevTransitTime)
|
|
{
|
|
astro_time_t startTime;
|
|
|
|
startTime = Astronomy_AddDays(prevTransitTime, 100.0);
|
|
return Astronomy_SearchTransit(body, startTime);
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Frees up all dynamic memory allocated by Astronomy Engine.
|
|
*
|
|
* Astronomy Engine uses dynamic memory allocation in only one place:
|
|
* it makes calculation of Pluto's orbit more efficient by caching 11 KB
|
|
* segments recycling them. To force purging this cache and
|
|
* freeing all the dynamic memory, you can call this function at any time.
|
|
* It is always safe to call, although it will slow down the very next
|
|
* calculation of Pluto's position for a nearby time value.
|
|
* Calling this function before your program exits is optional, but
|
|
* it will be helpful for leak-checkers like valgrind.
|
|
*/
|
|
void Astronomy_Reset(void)
|
|
{
|
|
int i;
|
|
for (i=0; i < PLUTO_NUM_STATES-1; ++i)
|
|
{
|
|
free(pluto_cache[i]);
|
|
pluto_cache[i] = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|