KJ135
/
sgp4
mirror of http://172.16.0.12:5000/LAMPSARToolSoftware/sgp4.git
4
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Moved doubles in sgp4 into structs

feature/19
Daniel Warner 2011-05-20 21:36:23 +01:00
parent 565dd6385c
commit 32457f4120
2 changed files with 378 additions and 381 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

493
SGP4.cpp
View File

@ -80,19 +80,29 @@ void SGP4::SetTle(const Tle& tle) {
throw new SatelliteException("Inclination out of range"); throw new SatelliteException("Inclination out of range");
} }
Initialize();
}
void SGP4::Initialize() {
/* /*
* recover original mean motion (xnodp) and semimajor axis (aodp) * recover original mean motion (xnodp) and semimajor axis (aodp)
* from input elements * from input elements
*/ */
const double a1 = pow(XKE / MeanMotion(), TWOTHIRD); const double a1 = pow(XKE / MeanMotion(), TWOTHIRD);
i_cosio_ = cos(Inclination()); common_consts_.cosio = cos(Inclination());
i_sinio_ = sin(Inclination()); common_consts_.sinio = sin(Inclination());
const double theta2 = i_cosio_ * i_cosio_; const double theta2 = common_consts_.cosio * common_consts_.cosio;
i_x3thm1_ = 3.0 * theta2 - 1.0; common_consts_.x3thm1 = 3.0 * theta2 - 1.0;
const double eosq = Eccentricity() * Eccentricity(); const double eosq = Eccentricity() * Eccentricity();
const double betao2 = 1.0 - eosq; const double betao2 = 1.0 - eosq;
const double betao = sqrt(betao2); const double betao = sqrt(betao2);
const double temp = (1.5 * CK2) * i_x3thm1_ / (betao * betao2); const double temp = (1.5 * CK2) * common_consts_.x3thm1 / (betao * betao2);
const double del1 = temp / (a1 * a1); const double del1 = temp / (a1 * a1);
const double a0 = a1 * (1.0 - del1 * (1.0 / 3.0 + del1 * (1.0 + del1 * 134.0 / 81.0))); const double a0 = a1 * (1.0 - del1 * (1.0 / 3.0 + del1 * (1.0 + del1 * 134.0 / 81.0)));
const double del0 = temp / (a0 * a0); const double del0 = temp / (a0 * a0);
@ -111,10 +121,13 @@ void SGP4::SetTle(const Tle& tle) {
perigee_ = (RecoveredSemiMajorAxis() * (1.0 - Eccentricity()) - AE) * XKMPER; perigee_ = (RecoveredSemiMajorAxis() * (1.0 - Eccentricity()) - AE) * XKMPER;
period_ = TWOPI / RecoveredMeanMotion(); period_ = TWOPI / RecoveredMeanMotion();
Initialize(theta2, betao2, betao, eosq);
}
void SGP4::Initialize(const double& theta2, const double& betao2, const double& betao, const double& eosq) {
if (Period() >= 225.0) { if (Period() >= 225.0) {
use_deep_space_ = true; use_deep_space_ = true;
@ -152,91 +165,91 @@ void SGP4::Initialize(const double& theta2, const double& betao2, const double&
*/ */
const double pinvsq = 1.0 / (RecoveredSemiMajorAxis() * RecoveredSemiMajorAxis() * betao2 * betao2); const double pinvsq = 1.0 / (RecoveredSemiMajorAxis() * RecoveredSemiMajorAxis() * betao2 * betao2);
const double tsi = 1.0 / (RecoveredSemiMajorAxis() - s4); const double tsi = 1.0 / (RecoveredSemiMajorAxis() - s4);
i_eta_ = RecoveredSemiMajorAxis() * Eccentricity() * tsi; common_consts_.eta = RecoveredSemiMajorAxis() * Eccentricity() * tsi;
const double etasq = i_eta_ * i_eta_; const double etasq = common_consts_.eta * common_consts_.eta;
const double eeta = Eccentricity() * i_eta_; const double eeta = Eccentricity() * common_consts_.eta;
const double psisq = fabs(1.0 - etasq); const double psisq = fabs(1.0 - etasq);
const double coef = qoms24 * pow(tsi, 4.0); const double coef = qoms24 * pow(tsi, 4.0);
const double coef1 = coef / pow(psisq, 3.5); const double coef1 = coef / pow(psisq, 3.5);
const double c2 = coef1 * RecoveredMeanMotion() * (RecoveredSemiMajorAxis() * const double c2 = coef1 * RecoveredMeanMotion() * (RecoveredSemiMajorAxis() *
(1.0 + 1.5 * etasq + eeta * (4.0 + etasq)) + (1.0 + 1.5 * etasq + eeta * (4.0 + etasq)) +
0.75 * CK2 * tsi / psisq * 0.75 * CK2 * tsi / psisq *
i_x3thm1_ * (8.0 + 3.0 * etasq * common_consts_.x3thm1 * (8.0 + 3.0 * etasq *
(8.0 + etasq))); (8.0 + etasq)));
i_c1_ = BStar() * c2; common_consts_.c1 = BStar() * c2;
i_a3ovk2_ = -XJ3 / CK2 * pow(AE, 3.0); common_consts_.a3ovk2 = -XJ3 / CK2 * pow(AE, 3.0);
i_x1mth2_ = 1.0 - theta2; common_consts_.x1mth2 = 1.0 - theta2;
i_c4_ = 2.0 * RecoveredMeanMotion() * coef1 * RecoveredSemiMajorAxis() * betao2 * common_consts_.c4 = 2.0 * RecoveredMeanMotion() * coef1 * RecoveredSemiMajorAxis() * betao2 *
(i_eta_ * (2.0 + 0.5 * etasq) + Eccentricity() * (0.5 + 2.0 * etasq) - (common_consts_.eta * (2.0 + 0.5 * etasq) + Eccentricity() * (0.5 + 2.0 * etasq) -
2.0 * CK2 * tsi / (RecoveredSemiMajorAxis() * psisq) * 2.0 * CK2 * tsi / (RecoveredSemiMajorAxis() * psisq) *
(-3.0 * i_x3thm1_ * (1.0 - 2.0 * eeta + etasq * (-3.0 * common_consts_.x3thm1 * (1.0 - 2.0 * eeta + etasq *
(1.5 - 0.5 * eeta)) + 0.75 * i_x1mth2_ * (2.0 * etasq - eeta * (1.5 - 0.5 * eeta)) + 0.75 * common_consts_.x1mth2 * (2.0 * etasq - eeta *
(1.0 + etasq)) * cos(2.0 * ArgumentPerigee()))); (1.0 + etasq)) * cos(2.0 * ArgumentPerigee())));
const double theta4 = theta2 * theta2; const double theta4 = theta2 * theta2;
const double temp1 = 3.0 * CK2 * pinvsq * RecoveredMeanMotion(); const double temp1 = 3.0 * CK2 * pinvsq * RecoveredMeanMotion();
const double temp2 = temp1 * CK2 * pinvsq; const double temp2 = temp1 * CK2 * pinvsq;
const double temp3 = 1.25 * CK4 * pinvsq * pinvsq * RecoveredMeanMotion(); const double temp3 = 1.25 * CK4 * pinvsq * pinvsq * RecoveredMeanMotion();
i_xmdot_ = RecoveredMeanMotion() + 0.5 * temp1 * betao * common_consts_.xmdot = RecoveredMeanMotion() + 0.5 * temp1 * betao *
i_x3thm1_ + 0.0625 * temp2 * betao * common_consts_.x3thm1 + 0.0625 * temp2 * betao *
(13.0 - 78.0 * theta2 + 137.0 * theta4); (13.0 - 78.0 * theta2 + 137.0 * theta4);
const double x1m5th = 1.0 - 5.0 * theta2; const double x1m5th = 1.0 - 5.0 * theta2;
i_omgdot_ = -0.5 * temp1 * x1m5th + common_consts_.omgdot = -0.5 * temp1 * x1m5th +
0.0625 * temp2 * (7.0 - 114.0 * theta2 + 395.0 * theta4) + 0.0625 * temp2 * (7.0 - 114.0 * theta2 + 395.0 * theta4) +
temp3 * (3.0 - 36.0 * theta2 + 49.0 * theta4); temp3 * (3.0 - 36.0 * theta2 + 49.0 * theta4);
const double xhdot1_ = -temp1 * i_cosio_; const double xhdot1_ = -temp1 * common_consts_.cosio;
i_xnodot_ = xhdot1_ + (0.5 * temp2 * (4.0 - 19.0 * theta2) + 2.0 * temp3 * common_consts_.xnodot = xhdot1_ + (0.5 * temp2 * (4.0 - 19.0 * theta2) + 2.0 * temp3 *
(3.0 - 7.0 * theta2)) * i_cosio_; (3.0 - 7.0 * theta2)) * common_consts_.cosio;
i_xnodcf_ = 3.5 * betao2 * xhdot1_ * i_c1_; common_consts_.xnodcf = 3.5 * betao2 * xhdot1_ * common_consts_.c1;
i_t2cof_ = 1.5 * i_c1_; common_consts_.t2cof = 1.5 * common_consts_.c1;
if (fabs(i_cosio_ + 1.0) > 1.5e-12) if (fabs(common_consts_.cosio + 1.0) > 1.5e-12)
i_xlcof_ = 0.125 * i_a3ovk2_ * i_sinio_ * (3.0 + 5.0 * i_cosio_) / (1.0 + i_cosio_); common_consts_.xlcof = 0.125 * common_consts_.a3ovk2 * common_consts_.sinio * (3.0 + 5.0 * common_consts_.cosio) / (1.0 + common_consts_.cosio);
else else
i_xlcof_ = 0.125 * i_a3ovk2_ * i_sinio_ * (3.0 + 5.0 * i_cosio_) / 1.5e-12; common_consts_.xlcof = 0.125 * common_consts_.a3ovk2 * common_consts_.sinio * (3.0 + 5.0 * common_consts_.cosio) / 1.5e-12;
i_aycof_ = 0.25 * i_a3ovk2_ * i_sinio_; common_consts_.aycof = 0.25 * common_consts_.a3ovk2 * common_consts_.sinio;
i_x7thm1_ = 7.0 * theta2 - 1.0; common_consts_.x7thm1 = 7.0 * theta2 - 1.0;
if (use_deep_space_) { if (use_deep_space_) {
d_gsto_ = Epoch().ToGreenwichSiderealTime(); deepspace_consts_.gsto = Epoch().ToGreenwichSiderealTime();
DeepSpaceInitialize(eosq, i_sinio_, i_cosio_, betao, DeepSpaceInitialize(eosq, common_consts_.sinio, common_consts_.cosio, betao,
theta2, betao2, theta2, betao2,
i_xmdot_, i_omgdot_, i_xnodot_); common_consts_.xmdot, common_consts_.omgdot, common_consts_.xnodot);
} else { } else {
double c3 = 0.0; double c3 = 0.0;
if (Eccentricity() > 1.0e-4) { if (Eccentricity() > 1.0e-4) {
c3 = coef * tsi * i_a3ovk2_ * RecoveredMeanMotion() * AE * c3 = coef * tsi * common_consts_.a3ovk2 * RecoveredMeanMotion() * AE *
i_sinio_ / Eccentricity(); common_consts_.sinio / Eccentricity();
} }
n_c5_ = 2.0 * coef1 * RecoveredSemiMajorAxis() * betao2 * (1.0 + 2.75 * nearspace_consts_.c5 = 2.0 * coef1 * RecoveredSemiMajorAxis() * betao2 * (1.0 + 2.75 *
(etasq + eeta) + eeta * etasq); (etasq + eeta) + eeta * etasq);
n_omgcof_ = BStar() * c3 * cos(ArgumentPerigee()); nearspace_consts_.omgcof = BStar() * c3 * cos(ArgumentPerigee());
n_xmcof_ = 0.0; nearspace_consts_.xmcof = 0.0;
if (Eccentricity() > 1.0e-4) if (Eccentricity() > 1.0e-4)
n_xmcof_ = -TWOTHIRD * coef * BStar() * AE / eeta; nearspace_consts_.xmcof = -TWOTHIRD * coef * BStar() * AE / eeta;
n_delmo_ = pow(1.0 + i_eta_ * (cos(MeanAnomoly())), 3.0); nearspace_consts_.delmo = pow(1.0 + common_consts_.eta * (cos(MeanAnomoly())), 3.0);
n_sinmo_ = sin(MeanAnomoly()); nearspace_consts_.sinmo = sin(MeanAnomoly());
if (!use_simple_model_) { if (!use_simple_model_) {
const double c1sq = i_c1_ * i_c1_; const double c1sq = common_consts_.c1 * common_consts_.c1;
n_d2_ = 4.0 * RecoveredSemiMajorAxis() * tsi * c1sq; nearspace_consts_.d2 = 4.0 * RecoveredSemiMajorAxis() * tsi * c1sq;
const double temp = n_d2_ * tsi * i_c1_ / 3.0; const double temp = nearspace_consts_.d2 * tsi * common_consts_.c1 / 3.0;
n_d3_ = (17.0 * RecoveredSemiMajorAxis() + s4) * temp; nearspace_consts_.d3 = (17.0 * RecoveredSemiMajorAxis() + s4) * temp;
n_d4_ = 0.5 * temp * RecoveredSemiMajorAxis() * nearspace_consts_.d4 = 0.5 * temp * RecoveredSemiMajorAxis() *
tsi * (221.0 * RecoveredSemiMajorAxis() + 31.0 * s4) * i_c1_; tsi * (221.0 * RecoveredSemiMajorAxis() + 31.0 * s4) * common_consts_.c1;
n_t3cof_ = n_d2_ + 2.0 * c1sq; nearspace_consts_.t3cof = nearspace_consts_.d2 + 2.0 * c1sq;
n_t4cof_ = 0.25 * (3.0 * n_d3_ + i_c1_ * nearspace_consts_.t4cof = 0.25 * (3.0 * nearspace_consts_.d3 + common_consts_.c1 *
(12.0 * n_d2_ + 10.0 * c1sq)); (12.0 * nearspace_consts_.d2 + 10.0 * c1sq));
n_t5cof_ = 0.2 * (3.0 * n_d4_ + 12.0 * i_c1_ * nearspace_consts_.t5cof = 0.2 * (3.0 * nearspace_consts_.d4 + 12.0 * common_consts_.c1 *
n_d3_ + 6.0 * n_d2_ * n_d2_ + 15.0 * nearspace_consts_.d3 + 6.0 * nearspace_consts_.d2 * nearspace_consts_.d2 + 15.0 *
c1sq * (2.0 * n_d2_ + c1sq)); c1sq * (2.0 * nearspace_consts_.d2 + c1sq));
} }
} }
@ -273,15 +286,15 @@ void SGP4::FindPositionSDP4(Eci* eci, double tsince) const {
/* /*
* update for secular gravity and atmospheric drag * update for secular gravity and atmospheric drag
*/ */
double xmdf = MeanAnomoly() + i_xmdot_ * tsince; double xmdf = MeanAnomoly() + common_consts_.xmdot * tsince;
double omgadf = ArgumentPerigee() + i_omgdot_ * tsince; double omgadf = ArgumentPerigee() + common_consts_.omgdot * tsince;
const double xnoddf = AscendingNode() + i_xnodot_ * tsince; const double xnoddf = AscendingNode() + common_consts_.xnodot * tsince;
const double tsq = tsince * tsince; const double tsq = tsince * tsince;
xnode = xnoddf + i_xnodcf_ * tsq; xnode = xnoddf + common_consts_.xnodcf * tsq;
double tempa = 1.0 - i_c1_ * tsince; double tempa = 1.0 - common_consts_.c1 * tsince;
double tempe = BStar() * i_c4_ * tsince; double tempe = BStar() * common_consts_.c4 * tsince;
double templ = i_t2cof_ * tsq; double templ = common_consts_.t2cof * tsq;
double xn = RecoveredMeanMotion(); double xn = RecoveredMeanMotion();
e = Eccentricity(); e = Eccentricity();
@ -352,11 +365,11 @@ void SGP4::FindPositionSDP4(Eci* eci, double tsince) const {
double perturbed_xlcof; double perturbed_xlcof;
if (fabs(perturbed_cosio + 1.0) > 1.5e-12) if (fabs(perturbed_cosio + 1.0) > 1.5e-12)
perturbed_xlcof = 0.125 * i_a3ovk2_ * perturbed_sinio * (3.0 + 5.0 * perturbed_cosio) / (1.0 + perturbed_cosio); perturbed_xlcof = 0.125 * common_consts_.a3ovk2 * perturbed_sinio * (3.0 + 5.0 * perturbed_cosio) / (1.0 + perturbed_cosio);
else else
perturbed_xlcof = 0.125 * i_a3ovk2_ * perturbed_sinio * (3.0 + 5.0 * perturbed_cosio) / 1.5e-12; perturbed_xlcof = 0.125 * common_consts_.a3ovk2 * perturbed_sinio * (3.0 + 5.0 * perturbed_cosio) / 1.5e-12;
const double perturbed_aycof = 0.25 * i_a3ovk2_ * perturbed_sinio; const double perturbed_aycof = 0.25 * common_consts_.a3ovk2 * perturbed_sinio;
/* /*
* using calculated values, find position and velocity * using calculated values, find position and velocity
@ -384,23 +397,23 @@ void SGP4::FindPositionSGP4(Eci* eci, double tsince) const {
/* /*
* update for secular gravity and atmospheric drag * update for secular gravity and atmospheric drag
*/ */
const double xmdf = MeanAnomoly() + i_xmdot_ * tsince; const double xmdf = MeanAnomoly() + common_consts_.xmdot * tsince;
const double omgadf = ArgumentPerigee() + i_omgdot_ * tsince; const double omgadf = ArgumentPerigee() + common_consts_.omgdot * tsince;
const double xnoddf = AscendingNode() + i_xnodot_ * tsince; const double xnoddf = AscendingNode() + common_consts_.xnodot * tsince;
const double tsq = tsince * tsince; const double tsq = tsince * tsince;
xnode = xnoddf + i_xnodcf_ * tsq; xnode = xnoddf + common_consts_.xnodcf * tsq;
double tempa = 1.0 - i_c1_ * tsince; double tempa = 1.0 - common_consts_.c1 * tsince;
double tempe = BStar() * i_c4_ * tsince; double tempe = BStar() * common_consts_.c4 * tsince;
double templ = i_t2cof_ * tsq; double templ = common_consts_.t2cof * tsq;
xincl = Inclination(); xincl = Inclination();
omega = omgadf; omega = omgadf;
double xmp = xmdf; double xmp = xmdf;
if (!use_simple_model_) { if (!use_simple_model_) {
const double delomg = n_omgcof_ * tsince; const double delomg = nearspace_consts_.omgcof * tsince;
const double delm = n_xmcof_ * (pow(1.0 + i_eta_ * cos(xmdf), 3.0) - n_delmo_); const double delm = nearspace_consts_.xmcof * (pow(1.0 + common_consts_.eta * cos(xmdf), 3.0) - nearspace_consts_.delmo);
const double temp = delomg + delm; const double temp = delomg + delm;
xmp += temp; xmp += temp;
@ -409,9 +422,9 @@ void SGP4::FindPositionSGP4(Eci* eci, double tsince) const {
const double tcube = tsq * tsince; const double tcube = tsq * tsince;
const double tfour = tsince * tcube; const double tfour = tsince * tcube;
tempa = tempa - n_d2_ * tsq - n_d3_ * tcube - n_d4_ * tfour; tempa = tempa - nearspace_consts_.d2 * tsq - nearspace_consts_.d3 * tcube - nearspace_consts_.d4 * tfour;
tempe += BStar() * n_c5_ * (sin(xmp) - n_sinmo_); tempe += BStar() * nearspace_consts_.c5 * (sin(xmp) - nearspace_consts_.sinmo);
templ += n_t3cof_ * tcube + tfour * (n_t4cof_ + tsince * n_t5cof_); templ += nearspace_consts_.t3cof * tcube + tfour * (nearspace_consts_.t4cof + tsince * nearspace_consts_.t5cof);
} }
a = RecoveredSemiMajorAxis() * pow(tempa, 2.0); a = RecoveredSemiMajorAxis() * pow(tempa, 2.0);
@ -440,9 +453,9 @@ void SGP4::FindPositionSGP4(Eci* eci, double tsince) const {
*/ */
CalculateFinalPositionVelocity(eci, tsince, e, CalculateFinalPositionVelocity(eci, tsince, e,
a, omega, xl, xnode, a, omega, xl, xnode,
xincl, i_xlcof_, i_aycof_, xincl, common_consts_.xlcof, common_consts_.aycof,
i_x3thm1_, i_x1mth2_, i_x7thm1_, common_consts_.x3thm1, common_consts_.x1mth2, common_consts_.x7thm1,
i_cosio_, i_sinio_); common_consts_.cosio, common_consts_.sinio);
} }
@ -647,9 +660,9 @@ void SGP4::DeepSpaceInitialize(const double& eosq, const double& sinio, const do
/* /*
* initialize lunar / solar terms * initialize lunar / solar terms
*/ */
const double d_day_ = Epoch().FromJan1_12h_1900(); const double jday = Epoch().FromJan1_12h_1900();
const double xnodce = 4.5236020 - 9.2422029e-4 * d_day_; const double xnodce = 4.5236020 - 9.2422029e-4 * jday;
const double xnodce_temp = fmod(xnodce, TWOPI); const double xnodce_temp = fmod(xnodce, TWOPI);
const double stem = sin(xnodce_temp); const double stem = sin(xnodce_temp);
const double ctem = cos(xnodce_temp); const double ctem = cos(xnodce_temp);
@ -657,9 +670,9 @@ void SGP4::DeepSpaceInitialize(const double& eosq, const double& sinio, const do
const double zsinil = sqrt(1.0 - zcosil * zcosil); const double zsinil = sqrt(1.0 - zcosil * zcosil);
const double zsinhl = 0.089683511 * stem / zsinil; const double zsinhl = 0.089683511 * stem / zsinil;
const double zcoshl = sqrt(1.0 - zsinhl * zsinhl); const double zcoshl = sqrt(1.0 - zsinhl * zsinhl);
const double c = 4.7199672 + 0.22997150 * d_day_; const double c = 4.7199672 + 0.22997150 * jday;
const double gam = 5.8351514 + 0.0019443680 * d_day_; const double gam = 5.8351514 + 0.0019443680 * jday;
d_zmol_ = Globals::Fmod2p(c - gam); deepspace_consts_.zmol = Globals::Fmod2p(c - gam);
double zx = 0.39785416 * stem / zsinil; double zx = 0.39785416 * stem / zsinil;
double zy = zcoshl * ctem + 0.91744867 * zsinhl * stem; double zy = zcoshl * ctem + 0.91744867 * zsinhl * stem;
zx = atan2(zx, zy); zx = atan2(zx, zy);
@ -667,7 +680,7 @@ void SGP4::DeepSpaceInitialize(const double& eosq, const double& sinio, const do
const double zcosgl = cos(zx); const double zcosgl = cos(zx);
const double zsingl = sin(zx); const double zsingl = sin(zx);
d_zmos_ = Globals::Fmod2p(6.2565837 + 0.017201977 * d_day_); deepspace_consts_.zmos = Globals::Fmod2p(6.2565837 + 0.017201977 * jday);
/* /*
* do solar terms * do solar terms
@ -744,41 +757,41 @@ void SGP4::DeepSpaceInitialize(const double& eosq, const double& sinio, const do
shdq = (-zn * s2 * (z21 + z23)) / sinio; shdq = (-zn * s2 * (z21 + z23)) / sinio;
} }
d_ee2_ = 2.0 * s1 * s6; deepspace_consts_.ee2 = 2.0 * s1 * s6;
d_e3_ = 2.0 * s1 * s7; deepspace_consts_.e3 = 2.0 * s1 * s7;
d_xi2_ = 2.0 * s2 * z12; deepspace_consts_.xi2 = 2.0 * s2 * z12;
d_xi3_ = 2.0 * s2 * (z13 - z11); deepspace_consts_.xi3 = 2.0 * s2 * (z13 - z11);
d_xl2_ = -2.0 * s3 * z2; deepspace_consts_.xl2 = -2.0 * s3 * z2;
d_xl3_ = -2.0 * s3 * (z3 - z1); deepspace_consts_.xl3 = -2.0 * s3 * (z3 - z1);
d_xl4_ = -2.0 * s3 * (-21.0 - 9.0 * eosq) * ze; deepspace_consts_.xl4 = -2.0 * s3 * (-21.0 - 9.0 * eosq) * ze;
d_xgh2_ = 2.0 * s4 * z32; deepspace_consts_.xgh2 = 2.0 * s4 * z32;
d_xgh3_ = 2.0 * s4 * (z33 - z31); deepspace_consts_.xgh3 = 2.0 * s4 * (z33 - z31);
d_xgh4_ = -18.0 * s4 * ze; deepspace_consts_.xgh4 = -18.0 * s4 * ze;
d_xh2_ = -2.0 * s2 * z22; deepspace_consts_.xh2 = -2.0 * s2 * z22;
d_xh3_ = -2.0 * s2 * (z23 - z21); deepspace_consts_.xh3 = -2.0 * s2 * (z23 - z21);
if (cnt == 1) if (cnt == 1)
break; break;
/* /*
* do lunar terms * do lunar terms
*/ */
d_sse_ = se; deepspace_consts_.sse = se;
d_ssi_ = si; deepspace_consts_.ssi = si;
d_ssl_ = sl; deepspace_consts_.ssl = sl;
d_ssh_ = shdq; deepspace_consts_.ssh = shdq;
d_ssg_ = sgh - cosio * d_ssh_; deepspace_consts_.ssg = sgh - cosio * deepspace_consts_.ssh;
d_se2_ = d_ee2_; deepspace_consts_.se2 = deepspace_consts_.ee2;
d_si2_ = d_xi2_; deepspace_consts_.si2 = deepspace_consts_.xi2;
d_sl2_ = d_xl2_; deepspace_consts_.sl2 = deepspace_consts_.xl2;
d_sgh2_ = d_xgh2_; deepspace_consts_.sgh2 = deepspace_consts_.xgh2;
d_sh2_ = d_xh2_; deepspace_consts_.sh2 = deepspace_consts_.xh2;
d_se3_ = d_e3_; deepspace_consts_.se3 = deepspace_consts_.e3;
d_si3_ = d_xi3_; deepspace_consts_.si3 = deepspace_consts_.xi3;
d_sl3_ = d_xl3_; deepspace_consts_.sl3 = deepspace_consts_.xl3;
d_sgh3_ = d_xgh3_; deepspace_consts_.sgh3 = deepspace_consts_.xgh3;
d_sh3_ = d_xh3_; deepspace_consts_.sh3 = deepspace_consts_.xh3;
d_sl4_ = d_xl4_; deepspace_consts_.sl4 = deepspace_consts_.xl4;
d_sgh4_ = d_xgh4_; deepspace_consts_.sgh4 = deepspace_consts_.xgh4;
zcosg = zcosgl; zcosg = zcosgl;
zsing = zsingl; zsing = zsingl;
zcosi = zcosil; zcosi = zcosil;
@ -790,15 +803,14 @@ void SGP4::DeepSpaceInitialize(const double& eosq, const double& sinio, const do
ze = ZEL; ze = ZEL;
} }
d_sse_ += se; deepspace_consts_.sse += se;
d_ssi_ += si; deepspace_consts_.ssi += si;
d_ssl_ += sl; deepspace_consts_.ssl += sl;
d_ssg_ += sgh - cosio * shdq; deepspace_consts_.ssg += sgh - cosio * shdq;
d_ssh_ += shdq; deepspace_consts_.ssh += shdq;
deepspace_consts_.resonance_flag = false;
d_resonance_flag_ = false; deepspace_consts_.synchronous_flag = false;
d_synchronous_flag_ = false;
bool initialize_integrator = true; bool initialize_integrator = true;
if (RecoveredMeanMotion() < 0.0052359877 && RecoveredMeanMotion() > 0.0034906585) { if (RecoveredMeanMotion() < 0.0052359877 && RecoveredMeanMotion() > 0.0034906585) {
@ -806,8 +818,8 @@ void SGP4::DeepSpaceInitialize(const double& eosq, const double& sinio, const do
/* /*
* 24h synchronous resonance terms initialization * 24h synchronous resonance terms initialization
*/ */
d_resonance_flag_ = true; deepspace_consts_.resonance_flag = true;
d_synchronous_flag_ = true; deepspace_consts_.synchronous_flag = true;
const double g200 = 1.0 + eosq * (-2.5 + 0.8125 * eosq); const double g200 = 1.0 + eosq * (-2.5 + 0.8125 * eosq);
const double g310 = 1.0 + 2.0 * eosq; const double g310 = 1.0 + 2.0 * eosq;
@ -816,14 +828,14 @@ void SGP4::DeepSpaceInitialize(const double& eosq, const double& sinio, const do
const double f311 = 0.9375 * sinio * sinio * (1.0 + 3.0 * cosio) - 0.75 * (1.0 + cosio); const double f311 = 0.9375 * sinio * sinio * (1.0 + 3.0 * cosio) - 0.75 * (1.0 + cosio);
double f330 = 1.0 + cosio; double f330 = 1.0 + cosio;
f330 = 1.875 * f330 * f330 * f330; f330 = 1.875 * f330 * f330 * f330;
d_del1_ = 3.0 * RecoveredMeanMotion() * RecoveredMeanMotion() * aqnv * aqnv; deepspace_consts_.del1 = 3.0 * RecoveredMeanMotion() * RecoveredMeanMotion() * aqnv * aqnv;
d_del2_ = 2.0 * d_del1_ * f220 * g200 * Q22; deepspace_consts_.del2 = 2.0 * deepspace_consts_.del1 * f220 * g200 * Q22;
d_del3_ = 3.0 * d_del1_ * f330 * g300 * Q33 * aqnv; deepspace_consts_.del3 = 3.0 * deepspace_consts_.del1 * f330 * g300 * Q33 * aqnv;
d_del1_ = d_del1_ * f311 * g310 * Q31 * aqnv; deepspace_consts_.del1 = deepspace_consts_.del1 * f311 * g310 * Q31 * aqnv;
d_xlamo_ = MeanAnomoly() + AscendingNode() + ArgumentPerigee() - d_gsto_; integrator_consts_.xlamo = MeanAnomoly() + AscendingNode() + ArgumentPerigee() - deepspace_consts_.gsto;
bfact = xmdot + xpidot - THDT; bfact = xmdot + xpidot - THDT;
bfact += d_ssl_ + d_ssg_ + d_ssh_; bfact += deepspace_consts_.ssl + deepspace_consts_.ssg + deepspace_consts_.ssh;
} else if (RecoveredMeanMotion() < 8.26e-3 || RecoveredMeanMotion() > 9.24e-3 || Eccentricity() < 0.5) { } else if (RecoveredMeanMotion() < 8.26e-3 || RecoveredMeanMotion() > 9.24e-3 || Eccentricity() < 0.5) {
initialize_integrator = false; initialize_integrator = false;
@ -831,7 +843,7 @@ void SGP4::DeepSpaceInitialize(const double& eosq, const double& sinio, const do
/* /*
* geopotential resonance initialization for 12 hour orbits * geopotential resonance initialization for 12 hour orbits
*/ */
d_resonance_flag_ = true; deepspace_consts_.resonance_flag = true;
const double eoc = Eccentricity() * eosq; const double eoc = Eccentricity() * eosq;
@ -900,41 +912,41 @@ void SGP4::DeepSpaceInitialize(const double& eosq, const double& sinio, const do
double temp1 = 3.0 * xno2 * ainv2; double temp1 = 3.0 * xno2 * ainv2;
double temp = temp1 * ROOT22; double temp = temp1 * ROOT22;
d_d2201_ = temp * f220 * g201; deepspace_consts_.d2201 = temp * f220 * g201;
d_d2211_ = temp * f221 * g211; deepspace_consts_.d2211 = temp * f221 * g211;
temp1 = temp1 * aqnv; temp1 = temp1 * aqnv;
temp = temp1 * ROOT32; temp = temp1 * ROOT32;
d_d3210_ = temp * f321 * g310; deepspace_consts_.d3210 = temp * f321 * g310;
d_d3222_ = temp * f322 * g322; deepspace_consts_.d3222 = temp * f322 * g322;
temp1 = temp1 * aqnv; temp1 = temp1 * aqnv;
temp = 2.0 * temp1 * ROOT44; temp = 2.0 * temp1 * ROOT44;
d_d4410_ = temp * f441 * g410; deepspace_consts_.d4410 = temp * f441 * g410;
d_d4422_ = temp * f442 * g422; deepspace_consts_.d4422 = temp * f442 * g422;
temp1 = temp1 * aqnv; temp1 = temp1 * aqnv;
temp = temp1 * ROOT52; temp = temp1 * ROOT52;
d_d5220_ = temp * f522 * g520; deepspace_consts_.d5220 = temp * f522 * g520;
d_d5232_ = temp * f523 * g532; deepspace_consts_.d5232 = temp * f523 * g532;
temp = 2.0 * temp1 * ROOT54; temp = 2.0 * temp1 * ROOT54;
d_d5421_ = temp * f542 * g521; deepspace_consts_.d5421 = temp * f542 * g521;
d_d5433_ = temp * f543 * g533; deepspace_consts_.d5433 = temp * f543 * g533;
d_xlamo_ = MeanAnomoly() + AscendingNode() + AscendingNode() - d_gsto_ - d_gsto_; integrator_consts_.xlamo = MeanAnomoly() + AscendingNode() + AscendingNode() - deepspace_consts_.gsto - deepspace_consts_.gsto;
bfact = xmdot + xnodot + xnodot - THDT - THDT; bfact = xmdot + xnodot + xnodot - THDT - THDT;
bfact = bfact + d_ssl_ + d_ssh_ + d_ssh_; bfact = bfact + deepspace_consts_.ssl + deepspace_consts_.ssh + deepspace_consts_.ssh;
} }
if (initialize_integrator) { if (initialize_integrator) {
/* /*
* initialize integrator * initialize integrator
*/ */
d_xfact_ = bfact - RecoveredMeanMotion(); integrator_consts_.xfact = bfact - RecoveredMeanMotion();
d_atime_ = 0.0; integrator_params_.atime = 0.0;
d_xni_ = RecoveredMeanMotion(); integrator_params_.xni = RecoveredMeanMotion();
d_xli_ = d_xlamo_; integrator_params_.xli = integrator_consts_.xlamo;
/* /*
* precompute dot terms for epoch * precompute dot terms for epoch
*/ */
DeepSpaceCalcDotTerms(&d_xndot_0_, &d_xnddt_0_, &d_xldot_0_); DeepSpaceCalcDotTerms(&integrator_consts_.xndot_0, &integrator_consts_.xnddt_0, &integrator_consts_.xldot_0);
} }
} }
@ -949,34 +961,34 @@ void SGP4::DeepSpaceCalculateLunarSolarTerms(const double t, double* pe, double*
/* /*
* calculate solar terms for time t * calculate solar terms for time t
*/ */
double zm = d_zmos_ + ZNS * t; double zm = deepspace_consts_.zmos + ZNS * t;
if (first_run_) if (first_run_)
zm = d_zmos_; zm = deepspace_consts_.zmos;
double zf = zm + 2.0 * ZES * sin(zm); double zf = zm + 2.0 * ZES * sin(zm);
double sinzf = sin(zf); double sinzf = sin(zf);
double f2 = 0.5 * sinzf * sinzf - 0.25; double f2 = 0.5 * sinzf * sinzf - 0.25;
double f3 = -0.5 * sinzf * cos(zf); double f3 = -0.5 * sinzf * cos(zf);
const double ses = d_se2_ * f2 + d_se3_ * f3; const double ses = deepspace_consts_.se2 * f2 + deepspace_consts_.se3 * f3;
const double sis = d_si2_ * f2 + d_si3_ * f3; const double sis = deepspace_consts_.si2 * f2 + deepspace_consts_.si3 * f3;
const double sls = d_sl2_ * f2 + d_sl3_ * f3 + d_sl4_ * sinzf; const double sls = deepspace_consts_.sl2 * f2 + deepspace_consts_.sl3 * f3 + deepspace_consts_.sl4 * sinzf;
const double sghs = d_sgh2_ * f2 + d_sgh3_ * f3 + d_sgh4_ * sinzf; const double sghs = deepspace_consts_.sgh2 * f2 + deepspace_consts_.sgh3 * f3 + deepspace_consts_.sgh4 * sinzf;
const double shs = d_sh2_ * f2 + d_sh3_ * f3; const double shs = deepspace_consts_.sh2 * f2 + deepspace_consts_.sh3 * f3;
/* /*
* calculate lunar terms for time t * calculate lunar terms for time t
*/ */
zm = d_zmol_ + ZNL * t; zm = deepspace_consts_.zmol + ZNL * t;
if (first_run_) if (first_run_)
zm = d_zmol_; zm = deepspace_consts_.zmol;
zf = zm + 2.0 * ZEL * sin(zm); zf = zm + 2.0 * ZEL * sin(zm);
sinzf = sin(zf); sinzf = sin(zf);
f2 = 0.5 * sinzf * sinzf - 0.25; f2 = 0.5 * sinzf * sinzf - 0.25;
f3 = -0.5 * sinzf * cos(zf); f3 = -0.5 * sinzf * cos(zf);
const double sel = d_ee2_ * f2 + d_e3_ * f3; const double sel = deepspace_consts_.ee2 * f2 + deepspace_consts_.e3 * f3;
const double sil = d_xi2_ * f2 + d_xi3_ * f3; const double sil = deepspace_consts_.xi2 * f2 + deepspace_consts_.xi3 * f3;
const double sll = d_xl2_ * f2 + d_xl3_ * f3 + d_xl4_ * sinzf; const double sll = deepspace_consts_.xl2 * f2 + deepspace_consts_.xl3 * f3 + deepspace_consts_.xl4 * sinzf;
const double sghl = d_xgh2_ * f2 + d_xgh3_ * f3 + d_xgh4_ * sinzf; const double sghl = deepspace_consts_.xgh2 * f2 + deepspace_consts_.xgh3 * f3 + deepspace_consts_.xgh4 * sinzf;
const double shl = d_xh2_ * f2 + d_xh3_ * f3; const double shl = deepspace_consts_.xh2 * f2 + deepspace_consts_.xh3 * f3;
/* /*
* merge calculated values * merge calculated values
@ -1092,48 +1104,48 @@ void SGP4::DeepSpaceSecular(const double& t, double* xll, double* omgasm,
static const double STEP = 720.0; static const double STEP = 720.0;
static const double STEP2 = 259200.0; static const double STEP2 = 259200.0;
(*xll) += d_ssl_ * t; (*xll) += deepspace_consts_.ssl * t;
(*omgasm) += d_ssg_ * t; (*omgasm) += deepspace_consts_.ssg * t;
(*xnodes) += d_ssh_ * t; (*xnodes) += deepspace_consts_.ssh * t;
(*em) += d_sse_ * t; (*em) += deepspace_consts_.sse * t;
(*xinc) += d_ssi_ * t; (*xinc) += deepspace_consts_.ssi * t;
if (!d_resonance_flag_) if (!deepspace_consts_.resonance_flag)
return; return;
/* /*
* 1st condition (if t is less than one time step from epoch) * 1st condition (if t is less than one time step from epoch)
* 2nd condition (if d_atime_ and t are of opposite signs, so zero crossing required) * 2nd condition (if integrator_params_.atime and t are of opposite signs, so zero crossing required)
* 3rd condition (if t is closer to zero than d_atime_, only integrate away from zero) * 3rd condition (if t is closer to zero than integrator_params_.atime, only integrate away from zero)
*/ */
if (fabs(t) < STEP || if (fabs(t) < STEP ||
t * d_atime_ <= 0.0 || t * integrator_params_.atime <= 0.0 ||
fabs(t) < fabs(d_atime_)) { fabs(t) < fabs(integrator_params_.atime)) {
/* /*
* restart from epoch * restart from epoch
*/ */
d_atime_ = 0.0; integrator_params_.atime = 0.0;
d_xni_ = RecoveredMeanMotion(); integrator_params_.xni = RecoveredMeanMotion();
d_xli_ = d_xlamo_; integrator_params_.xli = integrator_consts_.xlamo;
/* /*
* restore precomputed values for epoch * restore precomputed values for epoch
*/ */
d_xndot_t_ = d_xndot_0_; integrator_params_.xndot_t = integrator_consts_.xndot_0;
d_xnddt_t_ = d_xnddt_0_; integrator_params_.xnddt_t = integrator_consts_.xnddt_0;
d_xldot_t_ = d_xldot_0_; integrator_params_.xldot_t = integrator_consts_.xldot_0;
} }
double ft = t - d_atime_; double ft = t - integrator_params_.atime;
/* /*
* if time difference (ft) is greater than the time step (720.0) * if time difference (ft) is greater than the time step (720.0)
* loop around until d_atime_ is within one time step of t * loop around until integrator_params_.atime is within one time step of t
*/ */
if (fabs(ft) >= STEP) { if (fabs(ft) >= STEP) {
/* /*
* calculate step direction to allow d_atime_ * calculate step direction to allow integrator_params_.atime
* to catch up with t * to catch up with t
*/ */
double delt = -STEP; double delt = -STEP;
@ -1144,25 +1156,25 @@ void SGP4::DeepSpaceSecular(const double& t, double* xll, double* omgasm,
/* /*
* integrate using current dot terms * integrate using current dot terms
*/ */
DeepSpaceIntegrator(delt, STEP2, d_xndot_t_, d_xnddt_t_, d_xldot_t_); DeepSpaceIntegrator(delt, STEP2, integrator_params_.xndot_t, integrator_params_.xnddt_t, integrator_params_.xldot_t);
/* /*
* calculate dot terms for next integration * calculate dot terms for next integration
*/ */
DeepSpaceCalcDotTerms(&d_xndot_t_, &d_xnddt_t_, &d_xldot_t_); DeepSpaceCalcDotTerms(&integrator_params_.xndot_t, &integrator_params_.xnddt_t, &integrator_params_.xldot_t);
ft = t - d_atime_; ft = t - integrator_params_.atime;
} while (fabs(ft) >= STEP); } while (fabs(ft) >= STEP);
} }
/* /*
* integrator * integrator
*/ */
(*xn) = d_xni_ + d_xndot_t_ * ft + d_xnddt_t_ * ft * ft * 0.5; (*xn) = integrator_params_.xni + integrator_params_.xndot_t * ft + integrator_params_.xnddt_t * ft * ft * 0.5;
const double xl = d_xli_ + d_xldot_t_ * ft + d_xndot_t_ * ft * ft * 0.5; const double xl = integrator_params_.xli + integrator_params_.xldot_t * ft + integrator_params_.xndot_t * ft * ft * 0.5;
const double temp = -(*xnodes) + d_gsto_ + t * THDT; const double temp = -(*xnodes) + deepspace_consts_.gsto + t * THDT;
if (d_synchronous_flag_) if (deepspace_consts_.synchronous_flag)
(*xll) = xl + temp - (*omgasm); (*xll) = xl + temp - (*omgasm);
else else
(*xll) = xl + temp + temp; (*xll) = xl + temp + temp;
@ -1182,44 +1194,44 @@ void SGP4::DeepSpaceCalcDotTerms(double* xndot, double* xnddt, double* xldot) co
static const double FASX4 = 2.8843198; static const double FASX4 = 2.8843198;
static const double FASX6 = 0.37448087; static const double FASX6 = 0.37448087;
if (d_synchronous_flag_) { if (deepspace_consts_.synchronous_flag) {
(*xndot) = d_del1_ * sin(d_xli_ - FASX2) + (*xndot) = deepspace_consts_.del1 * sin(integrator_params_.xli - FASX2) +
d_del2_ * sin(2.0 * (d_xli_ - FASX4)) + deepspace_consts_.del2 * sin(2.0 * (integrator_params_.xli - FASX4)) +
d_del3_ * sin(3.0 * (d_xli_ - FASX6)); deepspace_consts_.del3 * sin(3.0 * (integrator_params_.xli - FASX6));
(*xnddt) = d_del1_ * cos(d_xli_ - FASX2) + 2.0 * (*xnddt) = deepspace_consts_.del1 * cos(integrator_params_.xli - FASX2) + 2.0 *
d_del2_ * cos(2.0 * (d_xli_ - FASX4)) + 3.0 * deepspace_consts_.del2 * cos(2.0 * (integrator_params_.xli - FASX4)) + 3.0 *
d_del3_ * cos(3.0 * (d_xli_ - FASX6)); deepspace_consts_.del3 * cos(3.0 * (integrator_params_.xli - FASX6));
} else { } else {
const double xomi = ArgumentPerigee() + i_omgdot_ * d_atime_; const double xomi = ArgumentPerigee() + common_consts_.omgdot * integrator_params_.atime;
const double x2omi = xomi + xomi; const double x2omi = xomi + xomi;
const double x2li = d_xli_ + d_xli_; const double x2li = integrator_params_.xli + integrator_params_.xli;
(*xndot) = d_d2201_ * sin(x2omi + d_xli_ - G22) (*xndot) = deepspace_consts_.d2201 * sin(x2omi + integrator_params_.xli - G22)
+ d_d2211_ * sin(d_xli_ - G22) + deepspace_consts_.d2211 * sin(integrator_params_.xli - G22)
+ d_d3210_ * sin(xomi + d_xli_ - G32) + deepspace_consts_.d3210 * sin(xomi + integrator_params_.xli - G32)
+ d_d3222_ * sin(-xomi + d_xli_ - G32) + deepspace_consts_.d3222 * sin(-xomi + integrator_params_.xli - G32)
+ d_d4410_ * sin(x2omi + x2li - G44) + deepspace_consts_.d4410 * sin(x2omi + x2li - G44)
+ d_d4422_ * sin(x2li - G44) + deepspace_consts_.d4422 * sin(x2li - G44)
+ d_d5220_ * sin(xomi + d_xli_ - G52) + deepspace_consts_.d5220 * sin(xomi + integrator_params_.xli - G52)
+ d_d5232_ * sin(-xomi + d_xli_ - G52) + deepspace_consts_.d5232 * sin(-xomi + integrator_params_.xli - G52)
+ d_d5421_ * sin(xomi + x2li - G54) + deepspace_consts_.d5421 * sin(xomi + x2li - G54)
+ d_d5433_ * sin(-xomi + x2li - G54); + deepspace_consts_.d5433 * sin(-xomi + x2li - G54);
(*xnddt) = d_d2201_ * cos(x2omi + d_xli_ - G22) (*xnddt) = deepspace_consts_.d2201 * cos(x2omi + integrator_params_.xli - G22)
+ d_d2211_ * cos(d_xli_ - G22) + deepspace_consts_.d2211 * cos(integrator_params_.xli - G22)
+ d_d3210_ * cos(xomi + d_xli_ - G32) + deepspace_consts_.d3210 * cos(xomi + integrator_params_.xli - G32)
+ d_d3222_ * cos(-xomi + d_xli_ - G32) + deepspace_consts_.d3222 * cos(-xomi + integrator_params_.xli - G32)
+ d_d5220_ * cos(xomi + d_xli_ - G52) + deepspace_consts_.d5220 * cos(xomi + integrator_params_.xli - G52)
+ d_d5232_ * cos(-xomi + d_xli_ - G52) + deepspace_consts_.d5232 * cos(-xomi + integrator_params_.xli - G52)
+ 2.0 * (d_d4410_ * cos(x2omi + x2li - G44) + 2.0 * (deepspace_consts_.d4410 * cos(x2omi + x2li - G44)
+ d_d4422_ * cos(x2li - G44) + deepspace_consts_.d4422 * cos(x2li - G44)
+ d_d5421_ * cos(xomi + x2li - G54) + deepspace_consts_.d5421 * cos(xomi + x2li - G54)
+ d_d5433_ * cos(-xomi + x2li - G54)); + deepspace_consts_.d5433 * cos(-xomi + x2li - G54));
} }
(*xldot) = d_xni_ + d_xfact_; (*xldot) = integrator_params_.xni + integrator_consts_.xfact;
(*xnddt) = (*xnddt) * (*xldot); (*xnddt) = (*xnddt) * (*xldot);
} }
@ -1232,13 +1244,13 @@ void SGP4::DeepSpaceIntegrator(const double delt, const double step2,
/* /*
* integrator * integrator
*/ */
d_xli_ += xldot * delt + xndot * step2; integrator_params_.xli += xldot * delt + xndot * step2;
d_xni_ += xndot * delt + xnddt * step2; integrator_params_.xni += xndot * delt + xnddt * step2;
/* /*
* increment integrator time * increment integrator time
*/ */
d_atime_ += delt; integrator_params_.atime += delt;
} }
void SGP4::Reset() { void SGP4::Reset() {
@ -1250,38 +1262,11 @@ void SGP4::Reset() {
use_simple_model_ = false; use_simple_model_ = false;
use_deep_space_ = false; use_deep_space_ = false;
i_cosio_ = i_sinio_ = i_eta_ = i_t2cof_ = i_a3ovk2_ = i_x1mth2_ = memset(&common_consts_, 0, sizeof (common_consts_));
i_x3thm1_ = i_x7thm1_ = i_aycof_ = i_xlcof_ = i_xnodcf_ = i_c1_ = memset(&nearspace_consts_, 0, sizeof (nearspace_consts_));
i_c4_ = i_omgdot_ = i_xnodot_ = i_xmdot_ = 0.0; memset(&deepspace_consts_, 0, sizeof (deepspace_consts_));
memset(&integrator_consts_, 0, sizeof (integrator_consts_));
/* memset(&integrator_params_, 0, sizeof (integrator_params_));
* near space variables
*/
n_c5_ = n_omgcof_ = n_xmcof_ = n_delmo_ = n_sinmo_ = n_d2_ =
n_d3_ = n_d4_ = n_t3cof_ = n_t4cof_ = n_t5cof_ = 0.0;
/*
* deep space variables
*/
d_gsto_ = d_zmol_ = d_zmos_ = 0.0;
d_resonance_flag_ = false;
d_synchronous_flag_ = false;
d_sse_ = d_ssi_ = d_ssl_ = d_ssg_ = d_ssh_ = 0.0;
d_se2_ = d_si2_ = d_sl2_ = d_sgh2_ = d_sh2_ = d_se3_ = d_si3_ = d_sl3_ =
d_sgh3_ = d_sh3_ = d_sl4_ = d_sgh4_ = d_ee2_ = d_e3_ = d_xi2_ =
d_xi3_ = d_xl2_ = d_xl3_ = d_xl4_ = d_xgh2_ = d_xgh3_ = d_xgh4_ =
d_xh2_ = d_xh3_ = 0.0;
d_d2201_ = d_d2211_ = d_d3210_ = d_d3222_ = d_d4410_ = d_d4422_ =
d_d5220_ = d_d5232_ = d_d5421_ = d_d5433_ = d_del1_ = d_del2_ =
d_del3_ = 0.0;
d_xfact_ = d_xlamo_ = d_xli_ = d_xni_ = d_atime_ =
d_xndot_0_ = d_xnddt_0_ = d_xldot_0_ =
d_xndot_t_ = d_xnddt_t_ = d_xldot_t_ = 0.0;
mean_anomoly_ = ascending_node_ = argument_perigee_ = eccentricity_ = mean_anomoly_ = ascending_node_ = argument_perigee_ = eccentricity_ =
inclination_ = mean_motion_ = bstar_ = recovered_semi_major_axis_ = inclination_ = mean_motion_ = bstar_ = recovered_semi_major_axis_ =

266
SGP4.h
View File

@ -93,9 +93,141 @@ public:
Julian Epoch() const { Julian Epoch() const {
return epoch_; return epoch_;
} }
struct CommonConstants {
double cosio;
double sinio;
double eta;
double t2cof;
double a3ovk2;
double x1mth2;
double x3thm1;
double x7thm1;
double aycof;
double xlcof;
double xnodcf;
double c1;
double c4;
double omgdot; // secular rate of omega (radians/sec)
double xnodot; // secular rate of xnode (radians/sec)
double xmdot; // secular rate of xmo (radians/sec)
};
struct NearSpaceConstants {
double c5;
double omgcof;
double xmcof;
double delmo;
double sinmo;
double d2;
double d3;
double d4;
double t3cof;
double t4cof;
double t5cof;
};
struct DeepSpaceConstants {
double gsto;
double zmol;
double zmos;
/*
* whether the deep space orbit is
* geopotential resonance for 12 hour orbits
*/
bool resonance_flag;
/*
* whether the deep space orbit is
* 24h synchronous resonance
*/
bool synchronous_flag;
/*
* lunar / solar constants for epoch
* applied during DeepSpaceSecular()
*/
double sse;
double ssi;
double ssl;
double ssg;
double ssh;
/*
* lunar / solar constants
* used during DeepSpaceCalculateLunarSolarTerms()
*/
double se2;
double si2;
double sl2;
double sgh2;
double sh2;
double se3;
double si3;
double sl3;
double sgh3;
double sh3;
double sl4;
double sgh4;
double ee2;
double e3;
double xi2;
double xi3;
double xl2;
double xl3;
double xl4;
double xgh2;
double xgh3;
double xgh4;
double xh2;
double xh3;
/*
* used during DeepSpaceCalcDotTerms()
*/
double d2201;
double d2211;
double d3210;
double d3222;
double d4410;
double d4422;
double d5220;
double d5232;
double d5421;
double d5433;
double del1;
double del2;
double del3;
};
struct IntegratorConstants {
/*
* integrator constants
*/
double xfact;
double xlamo;
/*
* integrator values for epoch
*/
double xndot_0;
double xnddt_0;
double xldot_0;
};
struct IntegratorParams {
/*
* integrator values
*/
double xli;
double xni;
double atime;
/*
* itegrator values for current d_atime_
*/
double xndot_t;
double xnddt_t;
double xldot_t;
};
private: private:
void Initialize(const double& theta2, const double& betao2, const double& betao, const double& eosq); void Initialize();
void DeepSpaceInitialize(const double& eosq, const double& sinio, const double& cosio, const double& betao, void DeepSpaceInitialize(const double& eosq, const double& sinio, const double& cosio, const double& betao,
const double& theta2, const double& betao2, const double& theta2, const double& betao2,
const double& xmdot, const double& omgdot, const double& xnodot); const double& xmdot, const double& omgdot, const double& xnodot);
@ -121,131 +253,11 @@ private:
bool use_simple_model_; bool use_simple_model_;
bool use_deep_space_; bool use_deep_space_;
/* struct CommonConstants common_consts_;
* variables are constants that wont be modified outside init struct NearSpaceConstants nearspace_consts_;
*/ struct DeepSpaceConstants deepspace_consts_;
double i_cosio_; struct IntegratorConstants integrator_consts_;
double i_sinio_; mutable struct IntegratorParams integrator_params_;
double i_eta_;
double i_t2cof_;
double i_a3ovk2_;
double i_x1mth2_;
double i_x3thm1_;
double i_x7thm1_;
double i_aycof_;
double i_xlcof_;
double i_xnodcf_;
double i_c1_;
double i_c4_;
double i_omgdot_; // secular rate of omega (radians/sec)
double i_xnodot_; // secular rate of xnode (radians/sec)
double i_xmdot_; // secular rate of xmo (radians/sec)
/*
* sgp4 constant
*/
double n_c5_;
double n_omgcof_;
double n_xmcof_;
double n_delmo_;
double n_sinmo_;
double n_d2_;
double n_d3_;
double n_d4_;
double n_t3cof_;
double n_t4cof_;
double n_t5cof_;
/*
* sdp4 constant
*/
double d_gsto_;
double d_zmol_;
double d_zmos_;
/*
* whether the deep space orbit is
* geopotential resonance for 12 hour orbits
*/
bool d_resonance_flag_;
/*
* whether the deep space orbit is
* 24h synchronous resonance
*/
bool d_synchronous_flag_;
/*
* lunar / solar constants for epoch
* applied during DeepSpaceSecular()
*/
double d_sse_;
double d_ssi_;
double d_ssl_;
double d_ssg_;
double d_ssh_;
/*
* lunar / solar constants
* used during DeepSpaceCalculateLunarSolarTerms()
*/
double d_se2_;
double d_si2_;
double d_sl2_;
double d_sgh2_;
double d_sh2_;
double d_se3_;
double d_si3_;
double d_sl3_;
double d_sgh3_;
double d_sh3_;
double d_sl4_;
double d_sgh4_;
double d_ee2_;
double d_e3_;
double d_xi2_;
double d_xi3_;
double d_xl2_;
double d_xl3_;
double d_xl4_;
double d_xgh2_;
double d_xgh3_;
double d_xgh4_;
double d_xh2_;
double d_xh3_;
/*
* used during DeepSpaceCalcDotTerms()
*/
double d_d2201_;
double d_d2211_;
double d_d3210_;
double d_d3222_;
double d_d4410_;
double d_d4422_;
double d_d5220_;
double d_d5232_;
double d_d5421_;
double d_d5433_;
double d_del1_;
double d_del2_;
double d_del3_;
/*
* integrator constants
*/
double d_xfact_;
double d_xlamo_;
/*
* integrator values
*/
mutable double d_xli_;
mutable double d_xni_;
mutable double d_atime_;
/*
* integrator values for epoch
*/
double d_xndot_0_;
double d_xnddt_0_;
double d_xldot_0_;
/*
* itegrator values for current d_atime_
*/
mutable double d_xndot_t_;
mutable double d_xnddt_t_;
mutable double d_xldot_t_;
/* /*
* these variables are set at the very start * these variables are set at the very start