325 lines
9.0 KiB
JavaScript
325 lines
9.0 KiB
JavaScript
'use strict';
|
||
|
||
Object.defineProperty(exports, '__esModule', { value: true });
|
||
|
||
var apparent = require('./apparent.cjs');
|
||
var base = require('./base.cjs');
|
||
var coord = require('./coord.cjs');
|
||
var kepler = require('./kepler.cjs');
|
||
var nutation = require('./nutation.cjs');
|
||
var planetposition = require('./planetposition.cjs');
|
||
var solarxyz = require('./solarxyz.cjs');
|
||
|
||
/**
|
||
* @copyright 2013 Sonia Keys
|
||
* @copyright 2016 commenthol
|
||
* @license MIT
|
||
* @module elliptic
|
||
*/
|
||
|
||
/**
|
||
* Position returns observed equatorial coordinates of a planet at a given time.
|
||
*
|
||
* Argument p must be a valid V87Planet object for the observed planet.
|
||
* Argument earth must be a valid V87Planet object for Earth.
|
||
*
|
||
* Results are right ascension and declination, α and δ in radians.
|
||
*/
|
||
function position (planet, earth, jde) { // (p, earth *pp.V87Planet, jde float64) (α, δ float64)
|
||
let x = 0;
|
||
let y = 0;
|
||
let z = 0;
|
||
const posEarth = earth.position(jde);
|
||
const [L0, B0, R0] = [posEarth.lon, posEarth.lat, posEarth.range];
|
||
const [sB0, cB0] = base["default"].sincos(B0);
|
||
const [sL0, cL0] = base["default"].sincos(L0);
|
||
|
||
function pos (τ = 0) {
|
||
const pos = planet.position(jde - τ);
|
||
const [L, B, R] = [pos.lon, pos.lat, pos.range];
|
||
const [sB, cB] = base["default"].sincos(B);
|
||
const [sL, cL] = base["default"].sincos(L);
|
||
x = R * cB * cL - R0 * cB0 * cL0;
|
||
y = R * cB * sL - R0 * cB0 * sL0;
|
||
z = R * sB - R0 * sB0;
|
||
}
|
||
|
||
pos();
|
||
const Δ = Math.sqrt(x * x + y * y + z * z); // (33.4) p. 224
|
||
const τ = base["default"].lightTime(Δ);
|
||
// repeating with jde-τ
|
||
pos(τ);
|
||
|
||
let λ = Math.atan2(y, x); // (33.1) p. 223
|
||
let β = Math.atan2(z, Math.hypot(x, y)); // (33.2) p. 223
|
||
const [Δλ, Δβ] = apparent["default"].eclipticAberration(λ, β, jde);
|
||
const fk5 = planetposition["default"].toFK5(λ + Δλ, β + Δβ, jde);
|
||
λ = fk5.lon;
|
||
β = fk5.lat;
|
||
const [Δψ, Δε] = nutation["default"].nutation(jde);
|
||
λ += Δψ;
|
||
const ε = nutation["default"].meanObliquity(jde) + Δε;
|
||
return new coord["default"].Ecliptic(λ, β).toEquatorial(ε)
|
||
// Meeus gives a formula for elongation but doesn't spell out how to
|
||
// obtaion term λ0 and doesn't give an example solution.
|
||
}
|
||
|
||
/**
|
||
* Elements holds keplerian elements.
|
||
*/
|
||
class Elements {
|
||
/*
|
||
Axis float64 // Semimajor axis, a, in AU
|
||
Ecc float64 // Eccentricity, e
|
||
Inc float64 // Inclination, i, in radians
|
||
ArgP float64 // Argument of perihelion, ω, in radians
|
||
Node float64 // Longitude of ascending node, Ω, in radians
|
||
TimeP float64 // Time of perihelion, T, as jde
|
||
*/
|
||
constructor (axis, ecc, inc, argP, node, timeP) {
|
||
let o = {};
|
||
if (typeof axis === 'object') {
|
||
o = axis;
|
||
}
|
||
this.axis = o.axis || axis;
|
||
this.ecc = o.ecc || ecc;
|
||
this.inc = o.inc || inc;
|
||
this.argP = o.argP || argP;
|
||
this.node = o.node || node;
|
||
this.timeP = o.timeP || timeP;
|
||
}
|
||
|
||
/**
|
||
* Position returns observed equatorial coordinates of a body with Keplerian elements.
|
||
*
|
||
* Argument e must be a valid V87Planet object for Earth.
|
||
*
|
||
* Results are right ascension and declination α and δ, and elongation ψ,
|
||
* all in radians.
|
||
*/
|
||
position (jde, earth) { // (α, δ, ψ float64) {
|
||
// (33.6) p. 227
|
||
const n = base["default"].K / this.axis / Math.sqrt(this.axis);
|
||
const sε = base["default"].SOblJ2000;
|
||
const cε = base["default"].COblJ2000;
|
||
const [sΩ, cΩ] = base["default"].sincos(this.node);
|
||
const [si, ci] = base["default"].sincos(this.inc);
|
||
// (33.7) p. 228
|
||
const F = cΩ;
|
||
const G = sΩ * cε;
|
||
const H = sΩ * sε;
|
||
const P = -sΩ * ci;
|
||
const Q = cΩ * ci * cε - si * sε;
|
||
const R = cΩ * ci * sε + si * cε;
|
||
// (33.8) p. 229
|
||
const A = Math.atan2(F, P);
|
||
const B = Math.atan2(G, Q);
|
||
const C = Math.atan2(H, R);
|
||
const a = Math.hypot(F, P);
|
||
const b = Math.hypot(G, Q);
|
||
const c = Math.hypot(H, R);
|
||
|
||
const f = (jde) => { // (x, y, z float64) {
|
||
const M = n * (jde - this.timeP);
|
||
let E;
|
||
try {
|
||
E = kepler["default"].kepler2b(this.ecc, M, 15);
|
||
} catch (e) {
|
||
E = kepler["default"].kepler3(this.ecc, M);
|
||
}
|
||
const ν = kepler["default"].trueAnomaly(E, this.ecc);
|
||
const r = kepler["default"].radius(E, this.ecc, this.axis);
|
||
// (33.9) p. 229
|
||
const x = r * a * Math.sin(A + this.argP + ν);
|
||
const y = r * b * Math.sin(B + this.argP + ν);
|
||
const z = r * c * Math.sin(C + this.argP + ν);
|
||
return { x, y, z }
|
||
};
|
||
return astrometricJ2000(f, jde, earth)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* AstrometricJ2000 is a utility function for computing astrometric coordinates.
|
||
*
|
||
* It is used internally and only exported so that it can be used from
|
||
* multiple packages. It is not otherwise expected to be used.
|
||
*
|
||
* Argument f is a function that returns J2000 equatorial rectangular
|
||
* coodinates of a body.
|
||
*
|
||
* Results are J2000 right ascention, declination, and elongation.
|
||
*/
|
||
function astrometricJ2000 (f, jde, earth) { // (f func(float64) (x, y, z float64), jde float64, e *pp.V87Planet) (α, δ, ψ float64)
|
||
const sol = solarxyz["default"].positionJ2000(earth, jde);
|
||
const [X, Y, Z] = [sol.x, sol.y, sol.z];
|
||
let ξ = 0;
|
||
let η = 0;
|
||
let ζ = 0;
|
||
let Δ = 0;
|
||
|
||
function fn (τ = 0) {
|
||
// (33.10) p. 229
|
||
const { x, y, z } = f(jde - τ);
|
||
ξ = X + x;
|
||
η = Y + y;
|
||
ζ = Z + z;
|
||
Δ = Math.sqrt(ξ * ξ + η * η + ζ * ζ);
|
||
}
|
||
|
||
fn();
|
||
const τ = base["default"].lightTime(Δ);
|
||
fn(τ);
|
||
|
||
let α = Math.atan2(η, ξ);
|
||
if (α < 0) {
|
||
α += 2 * Math.PI;
|
||
}
|
||
const δ = Math.asin(ζ / Δ);
|
||
const R0 = Math.sqrt(X * X + Y * Y + Z * Z);
|
||
const ψ = Math.acos((ξ * X + η * Y + ζ * Z) / R0 / Δ);
|
||
return new base["default"].Coord(α, δ, undefined, ψ)
|
||
}
|
||
|
||
/**
|
||
* Velocity returns instantaneous velocity of a body in elliptical orbit around the Sun.
|
||
*
|
||
* Argument a is the semimajor axis of the body, r is the instaneous distance
|
||
* to the Sun, both in AU.
|
||
*
|
||
* Result is in Km/sec.
|
||
*/
|
||
function velocity (a, r) { // (a, r float64) float64
|
||
return 42.1219 * Math.sqrt(1 / r - 0.5 / a)
|
||
}
|
||
|
||
/**
|
||
* Velocity returns the velocity of a body at aphelion.
|
||
*
|
||
* Argument a is the semimajor axis of the body in AU, e is eccentricity.
|
||
*
|
||
* Result is in Km/sec.
|
||
*/
|
||
function vAphelion (a, e) { // (a, e float64) float64
|
||
return 29.7847 * Math.sqrt((1 - e) / (1 + e) / a)
|
||
}
|
||
|
||
/**
|
||
* Velocity returns the velocity of a body at perihelion.
|
||
*
|
||
* Argument a is the semimajor axis of the body in AU, e is eccentricity.
|
||
*
|
||
* Result is in Km/sec.
|
||
*/
|
||
function vPerihelion (a, e) { // (a, e float64) float64
|
||
return 29.7847 * Math.sqrt((1 + e) / (1 - e) / a)
|
||
}
|
||
|
||
/**
|
||
* Length1 returns Ramanujan's approximation for the length of an elliptical
|
||
* orbit.
|
||
*
|
||
* Argument a is semimajor axis, e is eccentricity.
|
||
*
|
||
* Result is in units used for semimajor axis, typically AU.
|
||
*/
|
||
function length1 (a, e) { // (a, e float64) float64
|
||
const b = a * Math.sqrt(1 - e * e);
|
||
return Math.PI * (3 * (a + b) - Math.sqrt((a + 3 * b) * (3 * a + b)))
|
||
}
|
||
|
||
/**
|
||
* Length2 returns an alternate approximation for the length of an elliptical
|
||
* orbit.
|
||
*
|
||
* Argument a is semimajor axis, e is eccentricity.
|
||
*
|
||
* Result is in units used for semimajor axis, typically AU.
|
||
*/
|
||
function length2 (a, e) { // (a, e float64) float64
|
||
const b = a * Math.sqrt(1 - e * e);
|
||
const s = a + b;
|
||
const p = a * b;
|
||
const A = s * 0.5;
|
||
const G = Math.sqrt(p);
|
||
const H = 2 * p / s;
|
||
return Math.PI * (21 * A - 2 * G - 3 * H) * 0.125
|
||
}
|
||
|
||
/**
|
||
* Length3 returns the length of an elliptical orbit.
|
||
*
|
||
* Argument a is semimajor axis, e is eccentricity.
|
||
*
|
||
* Result is exact, and in units used for semimajor axis, typically AU.
|
||
*/
|
||
/* As Meeus notes, Length4 converges faster. There is no reason to use
|
||
this function
|
||
export function length3 (a, e) { // (a, e float64) float64
|
||
const sum0 = 1.0
|
||
const e2 = e * e
|
||
const term = e2 * 0.25
|
||
const sum1 = 1.0 - term
|
||
const nf = 1.0
|
||
const df = 2.0
|
||
while (sum1 !== sum0) {
|
||
term *= nf
|
||
nf += 2
|
||
df += 2
|
||
term *= nf * e2 / (df * df)
|
||
sum0 = sum1
|
||
sum1 -= term
|
||
}
|
||
return 2 * Math.PI * a * sum0
|
||
} */
|
||
|
||
/**
|
||
* Length4 returns the length of an elliptical orbit.
|
||
*
|
||
* Argument a is semimajor axis, e is eccentricity.
|
||
*
|
||
* Result is exact, and in units used for semimajor axis, typically AU.
|
||
*/
|
||
function length4 (a, e) { // (a, e float64) float64
|
||
const b = a * Math.sqrt(1 - e * e);
|
||
const m = (a - b) / (a + b);
|
||
const m2 = m * m;
|
||
let sum0 = 1.0;
|
||
let term = m2 * 0.25;
|
||
let sum1 = 1.0 + term;
|
||
let nf = -1.0;
|
||
let df = 2.0;
|
||
while (sum1 !== sum0) {
|
||
nf += 2;
|
||
df += 2;
|
||
term *= nf * nf * m2 / (df * df);
|
||
sum0 = sum1;
|
||
sum1 += term;
|
||
}
|
||
return 2 * Math.PI * a * sum0 / (1 + m)
|
||
}
|
||
|
||
var elliptic = {
|
||
position,
|
||
Elements,
|
||
astrometricJ2000,
|
||
velocity,
|
||
vAphelion,
|
||
vPerihelion,
|
||
length1,
|
||
length2,
|
||
// length3,
|
||
length4
|
||
};
|
||
|
||
exports.Elements = Elements;
|
||
exports.astrometricJ2000 = astrometricJ2000;
|
||
exports["default"] = elliptic;
|
||
exports.length1 = length1;
|
||
exports.length2 = length2;
|
||
exports.length4 = length4;
|
||
exports.position = position;
|
||
exports.vAphelion = vAphelion;
|
||
exports.vPerihelion = vPerihelion;
|
||
exports.velocity = velocity;
|