@saber-usa/node-common 1.6.207

package/src/ShadowGEOCalculator.js

@@ -0,0 +1,201 @@
+const constants = require("./constants.js");
+const solar = require("solar-calculator");
+const THREE = require("three");
+const {wrapToRange} = require("./utils.js");
+const {sunPosAt} = require("./astro.js");
+
+class ShadowGEOCalculator {
+    constructor() {
+        this.constants = constants;
+        this.solarCalculator = solar;
+        this.sunRadiusKm = 695700; // Radius of the Sun in kilometers,  (source: orekit, through resolution B3 from IAU 2015)
+        // 695701 in astro library
+    }
+
+    static _calculateUmbraGeometry(deltaPS) {
+        const Dp = 2 * constants.WGS84_EARTH_EQUATORIAL_RADIUS_KM;
+        const Ds = 2 * 695700; // sunRadiusKm
+
+        // Distance from Earth center to umbra apex
+        const Xu = (Dp * deltaPS) / (Ds - Dp);
+
+        // Umbra subtended angle
+        const alphaU = Math.asin(Dp / (2 * Xu));
+
+        return {Xu, alphaU};
+    }
+
+    static _calculatePenumbraGeometry(deltaPS) {
+        const Dp = 2 * constants.WGS84_EARTH_EQUATORIAL_RADIUS_KM;
+        const Ds = 2 * 695700; // sunRadiusKm
+
+        // Distance from Earth center to penumbra apex
+        const Xp = (Dp * deltaPS) / (Ds + Dp);
+
+        // Penumbra subtended angle
+        const alphaP = Math.asin(Dp / (2 * Xp));
+
+        return {Xp, alphaP};
+    }
+
+    static _umbraRadiusDistance(distance, Xu, alphaU) {
+        if (distance > Xu) {
+            throw new Error("Distance must be less than or equal to the umbra apex distance.");
+        }
+        // Calculate the radius of the umbra at a given distance from the apex
+        return (Xu - distance) * Math.tan(alphaU);
+    }
+
+    static _penumbraRadiusDistance(distance, Xp, alphaP) {
+        // Calculate the radius of the penumbra at a given distance from the apex
+        return (distance + Math.abs(Xp)) * Math.tan(alphaP);
+    }
+
+    static _sunUnitVector(sunLongitude, sunDeclination) {
+        const sunVector = new THREE.Vector3();
+        sunVector.x = Math.cos(sunDeclination * constants.DEG2RAD)
+            * Math.cos(sunLongitude * constants.DEG2RAD);
+        sunVector.y = Math.cos(sunDeclination * constants.DEG2RAD)
+            * Math.sin(sunLongitude * constants.DEG2RAD);
+        sunVector.z = Math.sin(sunDeclination * constants.DEG2RAD);
+        return sunVector; // returns the unit vector of the Sun's position
+    }
+
+    static _calculateSunDistance(sunLongitude, sunDeclination) {
+        // Longitude and declination (latitude) describe direction, not distance.
+        // To get the Earth-Sun distance in km, use astronomical data (mean ≈ 149,597,870.7 km).
+        // If you want the position vector in km, use the distance and direction:
+        const AU_KM = constants.AU_KM; // Astronomical Unit in kilometers
+        // AstroLibrary uses 149597900
+        const r = AU_KM; // Use actual Earth-Sun distance if available, otherwise mean AU
+
+        // Convert longitude and declination to a position vector in km
+        const x = r * Math.cos(sunDeclination * constants.DEG2RAD)
+            * Math.cos(sunLongitude * constants.DEG2RAD);
+        const y = r * Math.cos(sunDeclination * constants.DEG2RAD)
+            * Math.sin(sunLongitude * constants.DEG2RAD);
+        const z = r * Math.sin(sunDeclination * constants.DEG2RAD);
+
+        return {x, y, z, distance: r};
+    }
+
+    static geoBeltShadowIntersection(date) {
+        const [sunDeclination, sunLongitude] = sunPosAt(date);
+        // Calculate sun position
+        let deltaPS;
+        if (sunLongitude !== null && sunDeclination !== null) {
+            // convert sunLongitude and sunDeclination to distance in km
+            deltaPS = ShadowGEOCalculator._calculateSunDistance(
+                sunLongitude, sunDeclination)["distance"];
+        } else {
+            const time = new Date();
+            const [newSunDeclination, newSunLongitude] = sunPosAt(time);
+            const sunPositionData = ShadowGEOCalculator._calculateSunDistance(
+                newSunLongitude, newSunDeclination);
+            deltaPS = sunPositionData.distance;
+        }
+
+        // Calculate shadow geometry
+        const {Xu, alphaU} = ShadowGEOCalculator._calculateUmbraGeometry(deltaPS);
+        const {Xp, alphaP} = ShadowGEOCalculator._calculatePenumbraGeometry(deltaPS);
+
+        const geoRadius = constants.WGS84_EARTH_EQUATORIAL_RADIUS_KM + constants.GEO_ALTITUDE_KM;
+
+        // Calculate Shadow radii at GEO altitude
+        const umbraRadiusGEO = ShadowGEOCalculator._umbraRadiusDistance(geoRadius, Xu, alphaU);
+        const penumbraRadiusGEO = ShadowGEOCalculator._penumbraRadiusDistance(
+            geoRadius, Xp, alphaP);
+
+        // Calculate sun unit vector
+        const sunVector = ShadowGEOCalculator._sunUnitVector(sunLongitude, sunDeclination);
+
+        // Calculate shadow axis
+        const shadowAxis = [-sunVector.x, -sunVector.y, -sunVector.z];
+
+        // Finding shadow axis center in x, y, z coordinates
+
+        const shadowCenter = [
+            shadowAxis[0] * geoRadius,
+            shadowAxis[1] * geoRadius,
+            shadowAxis[2] * geoRadius,
+        ];
+
+        // Converting shadow axis to latitude and longitude
+        const shadowCenterLat = Math.asin(shadowCenter[2] / geoRadius) * constants.RAD2DEG;
+        const shadowCenterLon = Math.atan2(shadowCenter[1], shadowCenter[0]) * constants.RAD2DEG;
+
+        // Check if GEO belt intersects the shadow
+        const equatorialDistance = Math.abs(shadowCenter[2]); // Distance from the equator to the shadow center
+        const intersectsUmbra = umbraRadiusGEO > equatorialDistance;
+        const intersectsPenumbra = penumbraRadiusGEO > equatorialDistance;
+
+        const intersectionPoints = [];
+
+        if (intersectsPenumbra) {
+            // angle from the shadow center to the intersection point
+            const alpha = Math.sqrt(penumbraRadiusGEO**2 - equatorialDistance**2);
+            const theta = Math.atan2(alpha, geoRadius);
+
+            // Project shadow center onto the GEO belt
+            const shadowAxisEq = [shadowAxis[0], shadowAxis[1], 0];
+            const shadowAxisNorm = Math.sqrt(shadowAxisEq[0]**2 + shadowAxisEq[1]**2);
+            shadowAxisEq[0] /= shadowAxisNorm;
+            shadowAxisEq[1] /= shadowAxisNorm;
+
+            // Intersection points in the GEO belt
+            const centerLon = shadowCenterLon; // You already have this!
+
+            let lon1 = centerLon + theta * constants.RAD2DEG;
+            let lon2 = centerLon - theta * constants.RAD2DEG;
+
+            // Ensure longitudes are within -180 to 180 degrees
+            lon1 = wrapToRange(lon1, -180, 180);
+            lon2 = wrapToRange(lon2, -180, 180);
+
+            intersectionPoints.push({
+                type: "penumbra",
+                longitudeRange: [lon1, lon2],
+                latitude: 0, // Equatorial belt
+            });
+        }
+
+        if (intersectsUmbra) {
+            // angle from the shadow center to the intersection point
+            const alpha = Math.sqrt(umbraRadiusGEO**2 - equatorialDistance**2);
+            const theta = Math.atan2(alpha, geoRadius);
+
+            // Project shadow center onto the GEO belt
+            const shadowAxisEq = [shadowAxis[0], shadowAxis[1], 0];
+            const shadowAxisNorm = Math.sqrt(shadowAxisEq[0]**2 + shadowAxisEq[1]**2);
+            shadowAxisEq[0] /= shadowAxisNorm;
+            shadowAxisEq[1] /= shadowAxisNorm;
+
+            // Intersection points in the GEO belt
+            const centerLon = shadowCenterLon; // You already have this!
+
+            let lon1 = centerLon + theta * constants.RAD2DEG;
+            let lon2 = centerLon - theta * constants.RAD2DEG;
+
+            // Ensure longitudes are within -180 to 180 degrees
+            lon1 = ((lon1 + 180) % 360 + 360) % 360 - 180;
+            lon2 = ((lon2 + 180) % 360 + 360) % 360 - 180;
+
+            intersectionPoints.push({
+                type: "umbra",
+                longitudeRange: [lon1, lon2],
+                latitude: 0, // Equatorial belt
+            });
+        }
+
+        return {
+            shadowCenter: shadowCenter,
+            shadowCenterLat: shadowCenterLat,
+            shadowCenterLon: shadowCenterLon,
+            umbraRadiusGEO: umbraRadiusGEO,
+            penumbraRadiusGEO: penumbraRadiusGEO,
+            intersectionPoints: intersectionPoints,
+        };
+    }
+}
+
+module.exports = ShadowGEOCalculator;

package/src/TimeConverter.js

@@ -0,0 +1,311 @@
+// const {gstime} = require("satellite.js");
+
+/**
+ * TimeConverter - Port from C# TimeConverter
+ * Handles conversions between different time systems (UTC, UT1, TAI, GPS, TT)
+ * and Julian date calculations
+ */
+class TimeConverter {
+    // Constants from the C# implementation
+    static JULIAN_UTC = 2415018.5; // Julian Date of midnight, December 30, 1899
+    static JULIAN_MJD = 2400000.5; // = JD - MJD
+
+    // These values need to be changed periodically
+    // See http://www.stjarnhimlen.se/comp/time.html for bi-annual values (in seconds)
+    // See https://hpiers.obspm.fr/eoppc/eop/eopc04/eopc04_IAU2000.62-now for daily updated values
+    // As of 6/22/22:
+    static TAI_UTC = 37;
+    static GPS_UTC = 18;
+    static TT_UT1 = 69.29;
+    static UT1_UTC = -0.0977075;
+    static LOD = 0.0000022; // Length of day correction
+    static XP = 0.132949; // Polar motion X
+    static YP = 0.486774; // Polar motion Y
+
+    /**
+     * Constructor accepts either a UTC Date or a Julian date number
+     * @param {Date|number} input - Either a Date object (UTC) or a Julian date number
+     */
+    constructor(input) {
+        if (typeof input === "number") {
+            // Input is a Julian date
+            this._julian = input;
+            this._utc = null;
+        } else {
+            // Input is a Date object
+            this._utc = input instanceof Date ? input : new Date(input);
+            this._julian = null;
+        }
+    }
+
+    // Instance properties
+    get UTC() {
+        return this._utc || TimeConverter.julianToDateTime(this.JulianUTC);
+    }
+
+    get UT1() {
+        return TimeConverter.utcToUT1(this.UTC);
+    }
+
+    get TAI() {
+        return TimeConverter.utcToTAI(this.UTC);
+    }
+
+    get GPS() {
+        return TimeConverter.utcToGPS(this.UTC);
+    }
+
+    get TT() {
+        return TimeConverter.ut1ToTT(this.UT1);
+    }
+
+    get GMST() {
+        return TimeConverter.getGMST(this.JulianUT1);
+    }
+
+    get JulianUTC() {
+        return this._julian !== null ? this._julian : TimeConverter.dateTimeToJulian(this.UTC);
+    }
+
+    get JulianUT1() {
+        return TimeConverter.dateTimeToJulian(this.UT1);
+    }
+
+    get JulianTAI() {
+        return TimeConverter.dateTimeToJulian(this.TAI);
+    }
+
+    get JulianGPS() {
+        return TimeConverter.dateTimeToJulian(this.GPS);
+    }
+
+    get JulianTT() {
+        return TimeConverter.dateTimeToJulian(this.TT);
+    }
+
+    get JulianCenturiesTT() {
+        return TimeConverter.julianToCenturiesTxxx(this.JulianTT);
+    }
+
+    // Backwards compatibility property
+    get date() {
+        return this.UTC;
+    }
+
+    // Static factory methods
+    static FromJulianUTC(julian) {
+        return new TimeConverter(julian);
+    }
+
+    static FromGregorianUTC(date) {
+        return new TimeConverter(date);
+    }
+
+    /**
+     * Convert Julian date to JavaScript Date
+     * @param {number} julian - Julian date
+     * @return {Date} JavaScript Date object
+     */
+    static julianToDateTime(julian) {
+        // Using the C# formula: DateTime.FromOADate(julian - JULIAN_UTC)
+        // OLE Automation Date is days since Dec 30, 1899
+        const daysSince1899 = julian - TimeConverter.JULIAN_UTC;
+        const millisSince1899 = daysSince1899 * 86400000; // Convert days to milliseconds
+        const date1899 = new Date(Date.UTC(1899, 11, 30, 0, 0, 0, 0)); // Dec 30, 1899
+        return new Date(date1899.getTime() + millisSince1899);
+    }
+
+    /**
+     * Convert Date to Julian date
+     * @param {Date} date - JavaScript Date object
+     * @return {number} Julian date
+     */
+    static dateTimeToJulian(date) {
+        // Vallado Fundamentals, Algorithm 14 p. 183
+        const year = date.getUTCFullYear();
+        const month = date.getUTCMonth() + 1; // JavaScript months are 0-11
+        const day = date.getUTCDate();
+        const hour = date.getUTCHours();
+        const minute = date.getUTCMinutes();
+        const second = date.getUTCSeconds();
+        const millisecond = date.getUTCMilliseconds();
+
+        const jd = 367 * year - Math.floor(7 * (year + Math.floor((month + 9) / 12)) / 4)
+                   + Math.floor(275 * month / 9) + day + 1721013.5
+                   + (((second + millisecond * 1e-3) / 60 + minute) / 60 + hour) / 24;
+
+        return jd;
+    }
+
+    /**
+     * Convert Julian date to Modified Julian Date
+     * @param {number} julian - Julian date
+     * @return {number} Modified Julian Date
+     */
+    static JulianToMJD(julian) {
+        return julian - TimeConverter.JULIAN_MJD;
+    }
+
+    /**
+     * Convert Modified Julian Date to Julian date
+     * @param {number} mjd - Modified Julian Date
+     * @return {number} Julian date
+     */
+    static MJDToJulian(mjd) {
+        return mjd + TimeConverter.JULIAN_MJD;
+    }
+
+    /**
+     * Convert TAI to UTC
+     * @param {Date} tai - TAI time
+     * @return {Date} UTC time
+     */
+    static TAIToUTC(tai) {
+        const utcMillis = tai.getTime() - (TimeConverter.TAI_UTC * 1000);
+        return new Date(utcMillis);
+    }
+
+    /**
+     * Convert UTC to TAI
+     * @param {Date} utc - UTC time
+     * @return {Date} TAI time
+     */
+    static utcToTAI(utc) {
+        const taiMillis = utc.getTime() + (TimeConverter.TAI_UTC * 1000);
+        return new Date(taiMillis);
+    }
+
+    /**
+     * Convert GPS to UTC
+     * @param {Date} gps - GPS time
+     * @return {Date} UTC time
+     */
+    static GPSToUTC(gps) {
+        const utcMillis = gps.getTime() - (TimeConverter.GPS_UTC * 1000);
+        return new Date(utcMillis);
+    }
+
+    /**
+     * Convert UTC to GPS
+     * @param {Date} utc - UTC time
+     * @return {Date} GPS time
+     */
+    static utcToGPS(utc) {
+        const gpsMillis = utc.getTime() + (TimeConverter.GPS_UTC * 1000);
+        return new Date(gpsMillis);
+    }
+
+    /**
+     * Convert TT to UT1
+     * @param {Date} tt - Terrestrial Time
+     * @return {Date} UT1 time
+     */
+    static TTToUT1(tt) {
+        const ut1Millis = tt.getTime() - (TimeConverter.TT_UT1 * 1000);
+        return new Date(ut1Millis);
+    }
+
+    /**
+     * Convert UT1 to TT
+     * @param {Date} ut1 - UT1 time
+     * @return {Date} Terrestrial Time
+     */
+    static ut1ToTT(ut1) {
+        const ttMillis = ut1.getTime() + (TimeConverter.TT_UT1 * 1000);
+        return new Date(ttMillis);
+    }
+
+    /**
+     * Convert UT1 to UTC
+     * @param {Date} ut1 - UT1 time
+     * @return {Date} UTC time
+     */
+    static UT1ToUTC(ut1) {
+        const utcMillis = ut1.getTime() - (TimeConverter.UT1_UTC * 1000);
+        return new Date(utcMillis);
+    }
+
+    /**
+     * Convert UTC to UT1
+     * @param {Date} utc - UTC time
+     * @return {Date} UT1 time
+     */
+    static utcToUT1(utc) {
+        const ut1Millis = utc.getTime() + (TimeConverter.UT1_UTC * 1000);
+        return new Date(ut1Millis);
+    }
+
+    /**
+     * Get Greenwich Mean Sidereal Time from UT1 julian
+     * @param {number} jdut1 - Julian date UT1
+     * @param {boolean} wrap360 - Whether to wrap to 0-360 degrees
+     * @return {Object} Angle object with Radians property
+     */
+    static getGMST(jdut1, wrap360 = true) {
+        const tut1 = TimeConverter.julianToCenturiesTxxx(jdut1);
+        let gmst = -6.2e-6 * tut1 * tut1 * tut1 + 0.093104 * tut1 * tut1
+                  + (876600.0 * 3600 + 8640184.812866) * tut1 + 67310.54841; // seconds
+        gmst = gmst * (Math.PI / 180) / 240.0 % (2.0 * Math.PI); // 360/86400 = 1/240, to deg, to rad
+
+        // Check quadrants
+        if (gmst < 0.0 && wrap360) {
+            gmst += 2.0 * Math.PI;
+        }
+
+        return {
+            Radians: gmst,
+            Degrees: gmst * 180 / Math.PI,
+        };
+    }
+
+    /**
+     * Get Local Mean Sidereal Time from longitude and UT1 julian
+     * @param {number} lonDeg - Longitude in degrees (-180 to 180)
+     * @param {number} jdut1 - Julian date UT1
+     * @param {boolean} wrap360 - Whether to wrap to 0-360 degrees
+     * @return {Object} Object containing lmst (radians) and gmst (radians)
+     */
+    static GetLMST(lonDeg, jdut1, wrap360 = true) {
+        const gmstAngle = TimeConverter.getGMST(jdut1, wrap360);
+        const gmst = gmstAngle.Radians;
+        let lst = lonDeg * Math.PI / 180 + gmst;
+
+        // Check quadrants
+        lst %= 2.0 * Math.PI;
+        if (lst < 0.0 && wrap360) {
+            lst += 2.0 * Math.PI;
+        }
+
+        return {
+            lmst: lst,
+            gmst: gmst,
+        };
+    }
+
+    /**
+     * Convert Julian date to centuries since J2000
+     * @param {number} julian - Julian date
+     * @return {number} Centuries since J2000
+     */
+    static julianToCenturiesTxxx(julian) {
+        return (julian - 2451545.0) / 36525.0;
+    }
+}
+
+/**
+ * RaDec class for Right Ascension and Declination
+ */
+class RaDec {
+    constructor(raDeg, decDeg) {
+        this.RightAscension = {
+            Degrees: raDeg,
+            Radians: raDeg * Math.PI / 180,
+        };
+        this.Declination = {
+            Degrees: decDeg,
+            Radians: decDeg * Math.PI / 180,
+        };
+    }
+}
+
+module.exports = {TimeConverter, RaDec};