@saber-usa/node-common 1.7.7-alpha.2 → 1.7.7

package/src/PropagateUtils.js

@@ -1,100 +1,100 @@
-import {BallisticPropagator} from "./ballisticPropagator.js";
-import {RungeKutta4Propagator,
-    J2000,
-    KeplerPropagator,
-    EpochUTC,
-    ClassicalElements} from "pious-squid";
-import {sgp4} from "satellite.js";
-import {NodeVector3D} from "./NodeVector3D.js";
-import {cartesianToKeplerian, checkTle} from "./astro.js";
-import {DEG2RAD} from "./constants.js";
-
-const ReferenceFrame = {
-    ITRF: "ITRF",
-    J2000: "J2000",
-    TEME: "TEME",
-    GCRF: "GCRF",
-};
-
-class PropagateUtils {
-    static propagatorSelection(initialState, propagatorType, endTime) {
-        let propVal = null;
-        switch (propagatorType) {
-            case "NUMERICAL":
-                propVal = PropagateUtils.numericalPropagator(initialState, endTime);
-                break;
-            case "KEPLERIAN":
-                propVal = PropagateUtils.keplerianPropagator(initialState, endTime);
-                break;
-            case "ANALYTICAL":
-                propVal = PropagateUtils.analyticalPropagator(
-                    initialState, ReferenceFrame.J2000, endTime);
-                break;
-            case "TLE":
-                propVal = PropagateUtils.tlePropagator(initialState, endTime);
-                break;
-        }
-        return propVal;
-    }
-
-    static numericalPropagator(initialState, time) {
-        const state0 = new J2000(
-            new EpochUTC(initialState.epochUtc), initialState.position, initialState.velocity);
-        const prop = new RungeKutta4Propagator(state0);
-        const endTime = new EpochUTC(time);
-        const result = prop.propagate(endTime);
-        return result;
-    }
-
-    static analyticalPropagator(initialState, frame, time) {
-        const state = {
-            position: new NodeVector3D(
-                initialState.position.x, initialState.position.y, initialState.position.z), // km
-            velocity: new NodeVector3D(
-                initialState.velocity.x, initialState.velocity.y, initialState.velocity.z), // km/s
-            epochUtc: initialState.epochUtc,
-            referenceFrame: frame,
-        };
-
-        const propagator = new BallisticPropagator(state);
-        const result = propagator.propagate(time);
-        return result;
-    }
-
-    static keplerianPropagator(initialState, time) {
-        const elementsObjReal = cartesianToKeplerian(
-            initialState.position, initialState.velocity);
-
-        const elements = new ClassicalElements(
-            new EpochUTC(initialState.epoch),
-            elementsObjReal.a,
-            elementsObjReal.e,
-            elementsObjReal.i * DEG2RAD,
-            elementsObjReal.raan * DEG2RAD,
-            elementsObjReal.w * DEG2RAD,
-            elementsObjReal.f * DEG2RAD,
-        );
-
-        // Now pass to KeplerPropagator:
-        const prop = new KeplerPropagator(elements);
-
-        const result = prop.propagate(new EpochUTC(time));
-
-
-        return result;
-    }
-
-    static tlePropagator(tle, time) {
-        const line1 = tle[0];
-        const line2 = tle[1];
-        const satrec = checkTle(line1, line2);
-        if (!satrec) {
-            throw new Error("Invalid TLE data");
-        }
-        const result = sgp4(satrec, time);
-        return result;
-    }
-}
-
-export {PropagateUtils};
-
+import {BallisticPropagator} from "./ballisticPropagator.js";
+import {RungeKutta4Propagator,
+    J2000,
+    KeplerPropagator,
+    EpochUTC,
+    ClassicalElements} from "pious-squid";
+import {sgp4} from "satellite.js";
+import {NodeVector3D} from "./NodeVector3D.js";
+import {cartesianToKeplerian, checkTle} from "./astro.js";
+import {DEG2RAD} from "./constants.js";
+
+const ReferenceFrame = {
+    ITRF: "ITRF",
+    J2000: "J2000",
+    TEME: "TEME",
+    GCRF: "GCRF",
+};
+
+class PropagateUtils {
+    static propagatorSelection(initialState, propagatorType, endTime) {
+        let propVal = null;
+        switch (propagatorType) {
+            case "NUMERICAL":
+                propVal = PropagateUtils.numericalPropagator(initialState, endTime);
+                break;
+            case "KEPLERIAN":
+                propVal = PropagateUtils.keplerianPropagator(initialState, endTime);
+                break;
+            case "ANALYTICAL":
+                propVal = PropagateUtils.analyticalPropagator(
+                    initialState, ReferenceFrame.J2000, endTime);
+                break;
+            case "TLE":
+                propVal = PropagateUtils.tlePropagator(initialState, endTime);
+                break;
+        }
+        return propVal;
+    }
+
+    static numericalPropagator(initialState, time) {
+        const state0 = new J2000(
+            new EpochUTC(initialState.epochUtc), initialState.position, initialState.velocity);
+        const prop = new RungeKutta4Propagator(state0);
+        const endTime = new EpochUTC(time);
+        const result = prop.propagate(endTime);
+        return result;
+    }
+
+    static analyticalPropagator(initialState, frame, time) {
+        const state = {
+            position: new NodeVector3D(
+                initialState.position.x, initialState.position.y, initialState.position.z), // km
+            velocity: new NodeVector3D(
+                initialState.velocity.x, initialState.velocity.y, initialState.velocity.z), // km/s
+            epochUtc: initialState.epochUtc,
+            referenceFrame: frame,
+        };
+
+        const propagator = new BallisticPropagator(state);
+        const result = propagator.propagate(time);
+        return result;
+    }
+
+    static keplerianPropagator(initialState, time) {
+        const elementsObjReal = cartesianToKeplerian(
+            initialState.position, initialState.velocity);
+
+        const elements = new ClassicalElements(
+            new EpochUTC(initialState.epoch),
+            elementsObjReal.a,
+            elementsObjReal.e,
+            elementsObjReal.i * DEG2RAD,
+            elementsObjReal.raan * DEG2RAD,
+            elementsObjReal.w * DEG2RAD,
+            elementsObjReal.f * DEG2RAD,
+        );
+
+        // Now pass to KeplerPropagator:
+        const prop = new KeplerPropagator(elements);
+
+        const result = prop.propagate(new EpochUTC(time));
+
+
+        return result;
+    }
+
+    static tlePropagator(tle, time) {
+        const line1 = tle[0];
+        const line2 = tle[1];
+        const satrec = checkTle(line1, line2);
+        if (!satrec) {
+            throw new Error("Invalid TLE data");
+        }
+        const result = sgp4(satrec, time);
+        return result;
+    }
+}
+
+export {PropagateUtils};
+

package/src/ShadowGEOCalculator.js

@@ -1,203 +1,203 @@
-import constants, {WGS84_EARTH_EQUATORIAL_RADIUS_KM,
-    DEG2RAD, AU_KM as _AU_KM,
-    GEO_ALTITUDE_KM, RAD2DEG} from "./constants.js";
-import solar from "solar-calculator";
-import {Vector3} from "three";
-import {wrapToRange} from "./utils.js";
-import {sunPosAt} from "./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 * 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 * 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 Vector3();
-        sunVector.x = Math.cos(sunDeclination * DEG2RAD)
-            * Math.cos(sunLongitude * DEG2RAD);
-        sunVector.y = Math.cos(sunDeclination * DEG2RAD)
-            * Math.sin(sunLongitude * DEG2RAD);
-        sunVector.z = Math.sin(sunDeclination * 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 = _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 * DEG2RAD)
-            * Math.cos(sunLongitude * DEG2RAD);
-        const y = r * Math.cos(sunDeclination * DEG2RAD)
-            * Math.sin(sunLongitude * DEG2RAD);
-        const z = r * Math.sin(sunDeclination * 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 = WGS84_EARTH_EQUATORIAL_RADIUS_KM + 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) * RAD2DEG;
-        const shadowCenterLon = Math.atan2(shadowCenter[1], shadowCenter[0]) * 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 * RAD2DEG;
-            let lon2 = centerLon - theta * 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 * RAD2DEG;
-            let lon2 = centerLon - theta * 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,
-        };
-    }
-}
-
-export {ShadowGEOCalculator};
+import constants, {WGS84_EARTH_EQUATORIAL_RADIUS_KM,
+    DEG2RAD, AU_KM as _AU_KM,
+    GEO_ALTITUDE_KM, RAD2DEG} from "./constants.js";
+import solar from "solar-calculator";
+import {Vector3} from "three";
+import {wrapToRange} from "./utils.js";
+import {sunPosAt} from "./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 * 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 * 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 Vector3();
+        sunVector.x = Math.cos(sunDeclination * DEG2RAD)
+            * Math.cos(sunLongitude * DEG2RAD);
+        sunVector.y = Math.cos(sunDeclination * DEG2RAD)
+            * Math.sin(sunLongitude * DEG2RAD);
+        sunVector.z = Math.sin(sunDeclination * 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 = _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 * DEG2RAD)
+            * Math.cos(sunLongitude * DEG2RAD);
+        const y = r * Math.cos(sunDeclination * DEG2RAD)
+            * Math.sin(sunLongitude * DEG2RAD);
+        const z = r * Math.sin(sunDeclination * 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 = WGS84_EARTH_EQUATORIAL_RADIUS_KM + 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) * RAD2DEG;
+        const shadowCenterLon = Math.atan2(shadowCenter[1], shadowCenter[0]) * 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 * RAD2DEG;
+            let lon2 = centerLon - theta * 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 * RAD2DEG;
+            let lon2 = centerLon - theta * 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,
+        };
+    }
+}
+
+export {ShadowGEOCalculator};