DeepSDP4.java

  1. /* Copyright 2002-2020 CS GROUP
  2.  * Licensed to CS GROUP (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.propagation.analytical.tle;

  19. import org.hipparchus.util.FastMath;
  20. import org.hipparchus.util.MathUtils;
  21. import org.hipparchus.util.SinCos;
  22. import org.orekit.annotation.DefaultDataContext;
  23. import org.orekit.attitudes.AttitudeProvider;
  24. import org.orekit.data.DataContext;
  25. import org.orekit.frames.Frame;
  26. import org.orekit.time.DateTimeComponents;
  27. import org.orekit.utils.Constants;


  30. /** This class contains the methods that compute deep space perturbation terms.
  31.  * <p>
  32.  * The user should not bother in this class since it is handled internaly by the
  33.  * {@link TLEPropagator}.
  34.  * </p>
  35.  * <p>This implementation is largely inspired from the paper and source code <a
  36.  * href="https://www.celestrak.com/publications/AIAA/2006-6753/">Revisiting Spacetrack
  37.  * Report #3</a> and is fully compliant with its results and tests cases.</p>
  38.  * @author Felix R. Hoots, Ronald L. Roehrich, December 1980 (original fortran)
  39.  * @author David A. Vallado, Paul Crawford, Richard Hujsak, T.S. Kelso (C++ translation and improvements)
  40.  * @author Fabien Maussion (java translation)
  41.  */
  42. public class DeepSDP4 extends SDP4 {

  44.     // CHECKSTYLE: stop JavadocVariable check

  46.     // Internal constants
  47.     private static final double ZNS      = 1.19459E-5;
  48.     private static final double ZES      = 0.01675;
  49.     private static final double ZNL      = 1.5835218E-4;
  50.     private static final double ZEL      = 0.05490;
  51.     private static final double THDT     = 4.3752691E-3;
  52.     private static final double C1SS     =  2.9864797E-6;
  53.     private static final double C1L      = 4.7968065E-7;

  55.     private static final double ROOT22   = 1.7891679E-6;
  56.     private static final double ROOT32   = 3.7393792E-7;
  57.     private static final double ROOT44   = 7.3636953E-9;
  58.     private static final double ROOT52   = 1.1428639E-7;
  59.     private static final double ROOT54   = 2.1765803E-9;

  61.     private static final double Q22      =  1.7891679E-6;
  62.     private static final double Q31      =  2.1460748E-6;
  63.     private static final double Q33      =  2.2123015E-7;

  65.     private static final double C_FASX2  =  0.99139134268488593;
  66.     private static final double S_FASX2  =  0.13093206501640101;
  67.     private static final double C_2FASX4 =  0.87051638752972937;
  68.     private static final double S_2FASX4 = -0.49213943048915526;
  69.     private static final double C_3FASX6 =  0.43258117585763334;
  70.     private static final double S_3FASX6 =  0.90159499016666422;

  72.     private static final double C_G22    =  0.87051638752972937;
  73.     private static final double S_G22    = -0.49213943048915526;
  74.     private static final double C_G32    =  0.57972190187001149;
  75.     private static final double S_G32    =  0.81481440616389245;
  76.     private static final double C_G44    = -0.22866241528815548;
  77.     private static final double S_G44    =  0.97350577801807991;
  78.     private static final double C_G52    =  0.49684831179884198;
  79.     private static final double S_G52    =  0.86783740128127729;
  80.     private static final double C_G54    = -0.29695209575316894;
  81.     private static final double S_G54    = -0.95489237761529999;

  83.     /** Integration step (seconds). */
  84.     private static final double SECULAR_INTEGRATION_STEP  = 720.0;

  86.     /** Intermediate values. */
  87.     private double thgr;
  88.     private double xnq;
  89.     private double omegaq;
  90.     private double zcosil;
  91.     private double zsinil;
  92.     private double zsinhl;
  93.     private double zcoshl;
  94.     private double zmol;
  95.     private double zcosgl;
  96.     private double zsingl;
  97.     private double zmos;
  98.     private double savtsn;

  100.     private double ee2;
  101.     private double e3;
  102.     private double xi2;
  103.     private double xi3;
  104.     private double xl2;
  105.     private double xl3;
  106.     private double xl4;
  107.     private double xgh2;
  108.     private double xgh3;
  109.     private double xgh4;
  110.     private double xh2;
  111.     private double xh3;

  113.     private double d2201;
  114.     private double d2211;
  115.     private double d3210;
  116.     private double d3222;
  117.     private double d4410;
  118.     private double d4422;
  119.     private double d5220;
  120.     private double d5232;
  121.     private double d5421;
  122.     private double d5433;
  123.     private double xlamo;

  125.     private double sse;
  126.     private double ssi;
  127.     private double ssl;
  128.     private double ssh;
  129.     private double ssg;
  130.     private double se2;
  131.     private double si2;
  132.     private double sl2;
  133.     private double sgh2;
  134.     private double sh2;
  135.     private double se3;
  136.     private double si3;
  137.     private double sl3;
  138.     private double sgh3;
  139.     private double sh3;
  140.     private double sl4;
  141.     private double sgh4;

  143.     private double del1;
  144.     private double del2;
  145.     private double del3;
  146.     private double xfact;
  147.     private double xli;
  148.     private double xni;
  149.     private double atime;

  151.     private double pe;
  152.     private double pinc;
  153.     private double pl;
  154.     private double pgh;
  155.     private double ph;

  157.     private double[] derivs;

  159.     // CHECKSTYLE: resume JavadocVariable check

  161.     /** Flag for resonant orbits. */
  162.     private boolean resonant;

  164.     /** Flag for synchronous orbits. */
  165.     private boolean synchronous;

  167.     /** Flag for compliance with Dundee modifications. */
  168.     private boolean isDundeeCompliant = true;

  170.     /** Constructor for a unique initial TLE.
  171.      *
  172.      * <p>This constructor uses the {@link DataContext#getDefault() default data context}.
  173.      *
  174.      * @param initialTLE the TLE to propagate.
  175.      * @param attitudeProvider provider for attitude computation
  176.      * @param mass spacecraft mass (kg)
  177.      * @see #DeepSDP4(TLE, AttitudeProvider, double, Frame)
  178.      */
  179.     @DefaultDataContext
  180.     public DeepSDP4(final TLE initialTLE, final AttitudeProvider attitudeProvider,
  181.                     final double mass) {
  182.         this(initialTLE, attitudeProvider, mass,
  183.                 DataContext.getDefault().getFrames().getTEME());
  184.     }

  186.     /** Constructor for a unique initial TLE.
  187.      * @param initialTLE the TLE to propagate.
  188.      * @param attitudeProvider provider for attitude computation
  189.      * @param mass spacecraft mass (kg)
  190.      * @param teme the TEME frame to use for propagation.
  191.      * @since 10.1
  192.      */
  193.     public DeepSDP4(final TLE initialTLE,
  194.                     final AttitudeProvider attitudeProvider,
  195.                     final double mass,
  196.                     final Frame teme) {
  197.         super(initialTLE, attitudeProvider, mass, teme);
  198.     }

  200.     /** Computes luni - solar terms from initial coordinates and epoch.
  201.      */
  202.     protected void luniSolarTermsComputation() {

  204.         final SinCos scg  = FastMath.sinCos(tle.getPerigeeArgument());
  205.         final double sing = scg.sin();
  206.         final double cosg = scg.cos();

  208.         final SinCos scq  = FastMath.sinCos(tle.getRaan());
  209.         final double sinq = scq.sin();
  210.         final double cosq = scq.cos();
  211.         final double aqnv = 1.0 / a0dp;

  213.         // Compute julian days since 1900
  214.         final double daysSince1900 = (tle.getDate()
  215.                 .getComponents(utc)
  216.                 .offsetFrom(DateTimeComponents.JULIAN_EPOCH)) /
  217.                 Constants.JULIAN_DAY - 2415020;

  219.         double cc = C1SS;
  220.         double ze = ZES;
  221.         double zn = ZNS;
  222.         double zsinh = sinq;
  223.         double zcosh = cosq;

  225.         thgr = thetaG(tle.getDate());
  226.         xnq = xn0dp;
  227.         omegaq = tle.getPerigeeArgument();

  229.         final double xnodce = 4.5236020 - 9.2422029e-4 * daysSince1900;
  230.         final SinCos scTem  = FastMath.sinCos(xnodce);
  231.         final double stem   = scTem.sin();
  232.         final double ctem   = scTem.cos();
  233.         final double c_minus_gam = 0.228027132 * daysSince1900 - 1.1151842;
  234.         final double gam = 5.8351514 + 0.0019443680 * daysSince1900;

  236.         zcosil = 0.91375164 - 0.03568096 * ctem;
  237.         zsinil = FastMath.sqrt(1.0 - zcosil * zcosil);
  238.         zsinhl = 0.089683511 * stem / zsinil;
  239.         zcoshl = FastMath.sqrt(1.0 - zsinhl * zsinhl);
  240.         zmol = MathUtils.normalizeAngle(c_minus_gam, FastMath.PI);

  242.         double zx = 0.39785416 * stem / zsinil;
  243.         final double zy = zcoshl * ctem + 0.91744867 * zsinhl * stem;
  244.         zx = FastMath.atan2( zx, zy) + gam - xnodce;
  245.         final SinCos scZx = FastMath.sinCos(zx);
  246.         zcosgl = scZx.cos();
  247.         zsingl = scZx.sin();
  248.         zmos = MathUtils.normalizeAngle(6.2565837 + 0.017201977 * daysSince1900, FastMath.PI);

  250.         // Do solar terms
  251.         savtsn = 1e20;

  253.         double zcosi =  0.91744867;
  254.         double zsini =  0.39785416;
  255.         double zsing = -0.98088458;
  256.         double zcosg =  0.1945905;

  258.         double se = 0;
  259.         double sgh = 0;
  260.         double sh = 0;
  261.         double si = 0;
  262.         double sl = 0;

  264.         // There was previously some convoluted logic here, but it boils
  265.         // down to this:  we compute the solar terms,  then the lunar terms.
  266.         // On a second pass,  we recompute the solar terms, taking advantage
  267.         // of the improved data that resulted from computing lunar terms.
  268.         for (int iteration = 0; iteration < 2; ++iteration) {
  269.             final double a1 = zcosg * zcosh + zsing * zcosi * zsinh;
  270.             final double a3 = -zsing * zcosh + zcosg * zcosi * zsinh;
  271.             final double a7 = -zcosg * zsinh + zsing * zcosi * zcosh;
  272.             final double a8 = zsing * zsini;
  273.             final double a9 = zsing * zsinh + zcosg * zcosi * zcosh;
  274.             final double a10 = zcosg * zsini;
  275.             final double a2 = cosi0 * a7 + sini0 * a8;
  276.             final double a4 = cosi0 * a9 + sini0 * a10;
  277.             final double a5 = -sini0 * a7 + cosi0 * a8;
  278.             final double a6 = -sini0 * a9 + cosi0 * a10;
  279.             final double x1 = a1 * cosg + a2 * sing;
  280.             final double x2 = a3 * cosg + a4 * sing;
  281.             final double x3 = -a1 * sing + a2 * cosg;
  282.             final double x4 = -a3 * sing + a4 * cosg;
  283.             final double x5 = a5 * sing;
  284.             final double x6 = a6 * sing;
  285.             final double x7 = a5 * cosg;
  286.             final double x8 = a6 * cosg;
  287.             final double z31 = 12 * x1 * x1 - 3 * x3 * x3;
  288.             final double z32 = 24 * x1 * x2 - 6 * x3 * x4;
  289.             final double z33 = 12 * x2 * x2 - 3 * x4 * x4;
  290.             final double z11 = -6 * a1 * a5 + e0sq * (-24 * x1 * x7 - 6 * x3 * x5);
  291.             final double z12 = -6 * (a1 * a6 + a3 * a5) +
  292.                                e0sq * (-24 * (x2 * x7 + x1 * x8) - 6 * (x3 * x6 + x4 * x5));
  293.             final double z13 = -6 * a3 * a6 + e0sq * (-24 * x2 * x8 - 6 * x4 * x6);
  294.             final double z21 = 6 * a2 * a5 + e0sq * (24 * x1 * x5 - 6 * x3 * x7);
  295.             final double z22 = 6 * (a4 * a5 + a2 * a6) +
  296.                                e0sq * (24 * (x2 * x5 + x1 * x6) - 6 * (x4 * x7 + x3 * x8));
  297.             final double z23 = 6 * a4 * a6 + e0sq * (24 * x2 * x6 - 6 * x4 * x8);
  298.             final double s3 = cc / xnq;
  299.             final double s2 = -0.5 * s3 / beta0;
  300.             final double s4 = s3 * beta0;
  301.             final double s1 = -15 * tle.getE() * s4;
  302.             final double s5 = x1 * x3 + x2 * x4;
  303.             final double s6 = x2 * x3 + x1 * x4;
  304.             final double s7 = x2 * x4 - x1 * x3;
  305.             double z1 = 3 * (a1 * a1 + a2 * a2) + z31 * e0sq;
  306.             double z2 = 6 * (a1 * a3 + a2 * a4) + z32 * e0sq;
  307.             double z3 = 3 * (a3 * a3 + a4 * a4) + z33 * e0sq;

  309.             z1 = z1 + z1 + beta02 * z31;
  310.             z2 = z2 + z2 + beta02 * z32;
  311.             z3 = z3 + z3 + beta02 * z33;
  312.             se = s1 * zn * s5;
  313.             si = s2 * zn * (z11 + z13);
  314.             sl = -zn * s3 * (z1 + z3 - 14 - 6 * e0sq);
  315.             sgh = s4 * zn * (z31 + z33 - 6);
  316.             if (tle.getI() < (FastMath.PI / 60.0)) {
  317.                 // inclination smaller than 3 degrees
  318.                 sh = 0;
  319.             } else {
  320.                 sh = -zn * s2 * (z21 + z23);
  321.             }
  322.             ee2  =  2 * s1 * s6;
  323.             e3   =  2 * s1 * s7;
  324.             xi2  =  2 * s2 * z12;
  325.             xi3  =  2 * s2 * (z13 - z11);
  326.             xl2  = -2 * s3 * z2;
  327.             xl3  = -2 * s3 * (z3 - z1);
  328.             xl4  = -2 * s3 * (-21 - 9 * e0sq) * ze;
  329.             xgh2 =  2 * s4 * z32;
  330.             xgh3 =  2 * s4 * (z33 - z31);
  331.             xgh4 = -18 * s4 * ze;
  332.             xh2  = -2 * s2 * z22;
  333.             xh3  = -2 * s2 * (z23 - z21);

  335.             if (iteration == 0) { // we compute lunar terms only on the first pass:
  336.                 sse = se;
  337.                 ssi = si;
  338.                 ssl = sl;
  339.                 ssh = (tle.getI() < (FastMath.PI / 60.0)) ? 0 : sh / sini0;
  340.                 ssg = sgh - cosi0 * ssh;
  341.                 se2 = ee2;
  342.                 si2 = xi2;
  343.                 sl2 = xl2;
  344.                 sgh2 = xgh2;
  345.                 sh2 = xh2;
  346.                 se3 = e3;
  347.                 si3 = xi3;
  348.                 sl3 = xl3;
  349.                 sgh3 = xgh3;
  350.                 sh3 = xh3;
  351.                 sl4 = xl4;
  352.                 sgh4 = xgh4;
  353.                 zcosg = zcosgl;
  354.                 zsing = zsingl;
  355.                 zcosi = zcosil;
  356.                 zsini = zsinil;
  357.                 zcosh = zcoshl * cosq + zsinhl * sinq;
  358.                 zsinh = sinq * zcoshl - cosq * zsinhl;
  359.                 zn = ZNL;
  360.                 cc = C1L;
  361.                 ze = ZEL;
  362.             }
  363.         } // end of solar - lunar - solar terms computation

  365.         sse += se;
  366.         ssi += si;
  367.         ssl += sl;
  368.         ssg += sgh - ((tle.getI() < (FastMath.PI / 60.0)) ? 0 : (cosi0 / sini0 * sh));
  369.         ssh += (tle.getI() < (FastMath.PI / 60.0)) ? 0 : sh / sini0;



  373.         //        Start the resonant-synchronous tests and initialization

  375.         double bfact = 0;

  377.         // if mean motion is 1.893053 to 2.117652 revs/day, and eccentricity >= 0.5,
  378.         // start of the 12-hour orbit, e > 0.5 section
  379.         if ((xnq >= 0.00826) && (xnq <= 0.00924) && (tle.getE() >= 0.5)) {

  381.             final double g201 = -0.306 - (tle.getE() - 0.64) * 0.440;
  382.             final double eoc = tle.getE() * e0sq;
  383.             final double sini2 = sini0 * sini0;
  384.             final double f220 = 0.75 * (1 + 2 * cosi0 + theta2);
  385.             final double f221 = 1.5 * sini2;
  386.             final double f321 =  1.875 * sini0 * (1 - 2 * cosi0 - 3 * theta2);
  387.             final double f322 = -1.875 * sini0 * (1 + 2 * cosi0 - 3 * theta2);
  388.             final double f441 = 35 * sini2 * f220;
  389.             final double f442 = 39.3750 * sini2 * sini2;
  390.             final double f522 = 9.84375 * sini0 * (sini2 * (1 - 2 * cosi0 - 5 * theta2) +
  391.                                                    0.33333333 * (-2 + 4 * cosi0 + 6 * theta2));
  392.             final double f523 = sini0 * (4.92187512 * sini2 * (-2 - 4 * cosi0 + 10 * theta2) +
  393.                                          6.56250012 * (1 + 2 * cosi0 - 3 * theta2));
  394.             final double f542 = 29.53125 * sini0 * (2 - 8 * cosi0 + theta2 * (-12 + 8 * cosi0 + 10 * theta2));
  395.             final double f543 = 29.53125 * sini0 * (-2 - 8 * cosi0 + theta2 * (12 + 8 * cosi0 - 10 * theta2));
  396.             final double g211;
  397.             final double g310;
  398.             final double g322;
  399.             final double g410;
  400.             final double g422;
  401.             final double g520;

  403.             resonant = true;       // it is resonant...
  404.             synchronous = false;     // but it's not synchronous

  406.             // Geopotential resonance initialization for 12 hour orbits :
  407.             if (tle.getE() <= 0.65) {
  408.                 g211 =    3.616  -   13.247  * tle.getE() +   16.290  * e0sq;
  409.                 g310 =  -19.302  +  117.390  * tle.getE() -  228.419  * e0sq +  156.591  * eoc;
  410.                 g322 =  -18.9068 +  109.7927 * tle.getE() -  214.6334 * e0sq +  146.5816 * eoc;
  411.                 g410 =  -41.122  +  242.694  * tle.getE() -  471.094  * e0sq +  313.953  * eoc;
  412.                 g422 = -146.407  +  841.880  * tle.getE() - 1629.014  * e0sq + 1083.435  * eoc;
  413.                 g520 = -532.114  + 3017.977  * tle.getE() - 5740.032  * e0sq + 3708.276  * eoc;
  414.             } else  {
  415.                 g211 =   -72.099 +   331.819 * tle.getE() -   508.738 * e0sq +   266.724 * eoc;
  416.                 g310 =  -346.844 +  1582.851 * tle.getE() -  2415.925 * e0sq +  1246.113 * eoc;
  417.                 g322 =  -342.585 +  1554.908 * tle.getE() -  2366.899 * e0sq +  1215.972 * eoc;
  418.                 g410 = -1052.797 +  4758.686 * tle.getE() -  7193.992 * e0sq +  3651.957 * eoc;
  419.                 g422 = -3581.69  + 16178.11  * tle.getE() - 24462.77  * e0sq + 12422.52  * eoc;
  420.                 if (tle.getE() <= 0.715) {
  421.                     g520 = 1464.74 - 4664.75 * tle.getE() + 3763.64 * e0sq;
  422.                 } else {
  423.                     g520 = -5149.66 + 29936.92 * tle.getE() - 54087.36 * e0sq + 31324.56 * eoc;
  424.                 }
  425.             }

  427.             final double g533;
  428.             final double g521;
  429.             final double g532;
  430.             if (tle.getE() < 0.7) {
  431.                 g533 = -919.2277  + 4988.61   * tle.getE() - 9064.77   * e0sq + 5542.21  * eoc;
  432.                 g521 = -822.71072 + 4568.6173 * tle.getE() - 8491.4146 * e0sq + 5337.524 * eoc;
  433.                 g532 = -853.666   + 4690.25   * tle.getE() - 8624.77   * e0sq + 5341.4   * eoc;
  434.             } else {
  435.                 g533 = -37995.78  + 161616.52 * tle.getE() - 229838.2  * e0sq + 109377.94 * eoc;
  436.                 g521 = -51752.104 + 218913.95 * tle.getE() - 309468.16 * e0sq + 146349.42 * eoc;
  437.                 g532 = -40023.88  + 170470.89 * tle.getE() - 242699.48 * e0sq + 115605.82 * eoc;
  438.             }

  440.             double temp1 = 3 * xnq * xnq * aqnv * aqnv;
  441.             double temp = temp1 * ROOT22;
  442.             d2201 = temp * f220 * g201;
  443.             d2211 = temp * f221 * g211;
  444.             temp1 *= aqnv;
  445.             temp = temp1 * ROOT32;
  446.             d3210 = temp * f321 * g310;
  447.             d3222 = temp * f322 * g322;
  448.             temp1 *= aqnv;
  449.             temp = 2 * temp1 * ROOT44;
  450.             d4410 = temp * f441 * g410;
  451.             d4422 = temp * f442 * g422;
  452.             temp1 *= aqnv;
  453.             temp = temp1 * ROOT52;
  454.             d5220 = temp * f522 * g520;
  455.             d5232 = temp * f523 * g532;
  456.             temp = 2 * temp1 * ROOT54;
  457.             d5421 = temp * f542 * g521;
  458.             d5433 = temp * f543 * g533;
  459.             xlamo = tle.getMeanAnomaly() + tle.getRaan() + tle.getRaan() - thgr - thgr;
  460.             bfact = xmdot + xnodot + xnodot - THDT - THDT;
  461.             bfact += ssl + ssh + ssh;
  462.         } else if ((xnq < 0.0052359877) && (xnq > 0.0034906585)) {
  463.             // if mean motion is .8 to 1.2 revs/day : (geosynch)

  465.             final double cosio_plus_1 = 1.0 + cosi0;
  466.             final double g200 = 1 + e0sq * (-2.5 + 0.8125  * e0sq);
  467.             final double g300 = 1 + e0sq * (-6   + 6.60937 * e0sq);
  468.             final double f311 = 0.9375 * sini0 * sini0 * (1 + 3 * cosi0) - 0.75 * cosio_plus_1;
  469.             final double g310 = 1 + 2 * e0sq;
  470.             final double f220 = 0.75 * cosio_plus_1 * cosio_plus_1;
  471.             final double f330 = 2.5 * f220 * cosio_plus_1;

  473.             resonant = true;
  474.             synchronous = true;

  476.             // Synchronous resonance terms initialization
  477.             del1 = 3 * xnq * xnq * aqnv * aqnv;
  478.             del2 = 2 * del1 * f220 * g200 * Q22;
  479.             del3 = 3 * del1 * f330 * g300 * Q33 * aqnv;
  480.             del1 = del1 * f311 * g310 * Q31 * aqnv;
  481.             xlamo = tle.getMeanAnomaly() + tle.getRaan() + tle.getPerigeeArgument() - thgr;
  482.             bfact = xmdot + omgdot + xnodot - THDT;
  483.             bfact = bfact + ssl + ssg + ssh;
  484.         } else {
  485.             // it's neither a high-e 12-hours orbit nor a geosynchronous:
  486.             resonant = false;
  487.             synchronous = false;
  488.         }

  490.         if (resonant) {
  491.             xfact = bfact - xnq;

  493.             // Initialize integrator
  494.             xli   = xlamo;
  495.             xni   = xnq;
  496.             atime = 0;
  497.         }
  498.         derivs = new double[2];
  499.     }

  501.     /** Computes secular terms from current coordinates and epoch.
  502.      * @param t offset from initial epoch (minutes)
  503.      */
  504.     protected void deepSecularEffects(final double t)  {

  506.         xll    += ssl * t;
  507.         omgadf += ssg * t;
  508.         xnode  += ssh * t;
  509.         em      = tle.getE() + sse * t;
  510.         xinc    = tle.getI() + ssi * t;

  512.         if (resonant) {
  513.             // If we're closer to t = 0 than to the currently-stored data
  514.             // from the previous call to this function,  then we're
  515.             // better off "restarting",  going back to the initial data.
  516.             // The Dundee code rigs things up to _always_ take 720-minute
  517.             // steps from epoch to end time,  except for the final step.
  518.             // Easiest way to arrange similar behavior in this code is
  519.             // just to always do a restart,  if we're in Dundee-compliant
  520.             // mode.
  521.             if (FastMath.abs(t) < FastMath.abs(t - atime) || isDundeeCompliant)  {
  522.                 // Epoch restart
  523.                 atime = 0;
  524.                 xni = xnq;
  525.                 xli = xlamo;
  526.             }
  527.             boolean lastIntegrationStep = false;
  528.             // if |step|>|step max| then do one step at step max
  529.             while (!lastIntegrationStep) {
  530.                 double delt = t - atime;
  531.                 if (delt > SECULAR_INTEGRATION_STEP) {
  532.                     delt = SECULAR_INTEGRATION_STEP;
  533.                 } else if (delt < -SECULAR_INTEGRATION_STEP) {
  534.                     delt = -SECULAR_INTEGRATION_STEP;
  535.                 } else {
  536.                     lastIntegrationStep = true;
  537.                 }

  539.                 computeSecularDerivs();

  541.                 final double xldot = xni + xfact;

  543.                 double xlpow = 1.;
  544.                 xli += delt * xldot;
  545.                 xni += delt * derivs[0];
  546.                 double delt_factor = delt;
  547.                 xlpow *= xldot;
  548.                 derivs[1] *= xlpow;
  549.                 delt_factor *= delt / 2;
  550.                 xli += delt_factor * derivs[0];
  551.                 xni += delt_factor * derivs[1];
  552.                 atime += delt;
  553.             }
  554.             xn = xni;
  555.             final double temp = -xnode + thgr + t * THDT;
  556.             xll = xli + temp + (synchronous ? -omgadf : temp);
  557.         }
  558.     }

  560.     /** Computes periodic terms from current coordinates and epoch.
  561.      * @param t offset from initial epoch (min)
  562.      */
  563.     protected void deepPeriodicEffects(final double t)  {

  565.         // If the time didn't change by more than 30 minutes,
  566.         // there's no good reason to recompute the perturbations;
  567.         // they don't change enough over so short a time span.
  568.         // However,  the Dundee code _always_ recomputes,  so if
  569.         // we're attempting to replicate its results,  we've gotta
  570.         // recompute everything,  too.
  571.         if ((FastMath.abs(savtsn - t) >= 30.0) || isDundeeCompliant)  {

  573.             savtsn = t;

  575.             // Update solar perturbations for time T
  576.             double zm = zmos + ZNS * t;
  577.             double zf = zm + 2 * ZES * FastMath.sin(zm);
  578.             SinCos sczf = FastMath.sinCos(zf);
  579.             double sinzf = sczf.sin();
  580.             double f2 = 0.5 * sinzf * sinzf - 0.25;
  581.             double f3 = -0.5 * sinzf * sczf.cos();
  582.             final double ses = se2 * f2 + se3 * f3;
  583.             final double sis = si2 * f2 + si3 * f3;
  584.             final double sls = sl2 * f2 + sl3 * f3 + sl4 * sinzf;
  585.             final double sghs = sgh2 * f2 + sgh3 * f3 + sgh4 * sinzf;
  586.             final double shs = sh2 * f2 + sh3 * f3;

  588.             // Update lunar perturbations for time T
  589.             zm = zmol + ZNL * t;
  590.             zf = zm + 2 * ZEL * FastMath.sin(zm);
  591.             sczf = FastMath.sinCos(zf);
  592.             sinzf = sczf.sin();
  593.             f2 =  0.5 * sinzf * sinzf - 0.25;
  594.             f3 = -0.5 * sinzf * sczf.cos();
  595.             final double sel = ee2 * f2 + e3 * f3;
  596.             final double sil = xi2 * f2 + xi3 * f3;
  597.             final double sll = xl2 * f2 + xl3 * f3 + xl4 * sinzf;
  598.             final double sghl = xgh2 * f2 + xgh3 * f3 + xgh4 * sinzf;
  599.             final double sh1 = xh2 * f2 + xh3 * f3;

  601.             // Sum the solar and lunar contributions
  602.             pe   = ses  + sel;
  603.             pinc = sis  + sil;
  604.             pl   = sls  + sll;
  605.             pgh  = sghs + sghl;
  606.             ph   = shs  + sh1;
  607.         }

  609.         xinc += pinc;

  611.         final SinCos scis = FastMath.sinCos(xinc);
  612.         final double sinis = scis.sin();
  613.         final double cosis = scis.cos();

  615.         /* Add solar/lunar perturbation correction to eccentricity: */
  616.         em     += pe;
  617.         xll    += pl;
  618.         omgadf += pgh;
  619.         xinc    = MathUtils.normalizeAngle(xinc, 0);

  621.         if (FastMath.abs(xinc) >= 0.2) {
  622.             // Apply periodics directly
  623.             final double temp_val = ph / sinis;
  624.             omgadf -= cosis * temp_val;
  625.             xnode += temp_val;
  626.         } else {
  627.             // Apply periodics with Lyddane modification
  628.             final SinCos scok  = FastMath.sinCos(xnode);
  629.             final double sinok = scok.sin();
  630.             final double cosok = scok.cos();
  631.             final double alfdp =  ph * cosok + (pinc * cosis + sinis) * sinok;
  632.             final double betdp = -ph * sinok + (pinc * cosis + sinis) * cosok;
  633.             final double delta_xnode = MathUtils.normalizeAngle(FastMath.atan2(alfdp, betdp) - xnode, 0);
  634.             final double dls = -xnode * sinis * pinc;
  635.             omgadf += dls - cosis * delta_xnode;
  636.             xnode  += delta_xnode;
  637.         }
  638.     }

  640.     /** Computes internal secular derivs. */
  641.     private void computeSecularDerivs() {

  643.         final SinCos sc_li  = FastMath.sinCos(xli);
  644.         final double sin_li = sc_li.sin();
  645.         final double cos_li = sc_li.cos();
  646.         final double sin_2li = 2. * sin_li * cos_li;
  647.         final double cos_2li = 2. * cos_li * cos_li - 1.;

  649.         // Dot terms calculated :
  650.         if (synchronous)  {
  651.             final double sin_3li = sin_2li * cos_li + cos_2li * sin_li;
  652.             final double cos_3li = cos_2li * cos_li - sin_2li * sin_li;
  653.             final double term1a = del1 * (sin_li  * C_FASX2  - cos_li  * S_FASX2);
  654.             final double term2a = del2 * (sin_2li * C_2FASX4 - cos_2li * S_2FASX4);
  655.             final double term3a = del3 * (sin_3li * C_3FASX6 - cos_3li * S_3FASX6);
  656.             final double term1b = del1 * (cos_li  * C_FASX2  + sin_li  * S_FASX2);
  657.             final double term2b = 2.0 * del2 * (cos_2li * C_2FASX4 + sin_2li * S_2FASX4);
  658.             final double term3b = 3.0 * del3 * (cos_3li * C_3FASX6 + sin_3li * S_3FASX6);
  659.             derivs[0] = term1a + term2a + term3a;
  660.             derivs[1] = term1b + term2b + term3b;
  661.         } else {
  662.             // orbit is a 12-hour resonant one
  663.             final double xomi = omegaq + omgdot * atime;
  664.             final SinCos sc_omi  = FastMath.sinCos(xomi);
  665.             final double sin_omi = sc_omi.sin();
  666.             final double cos_omi = sc_omi.cos();
  667.             final double sin_li_m_omi = sin_li * cos_omi - sin_omi * cos_li;
  668.             final double sin_li_p_omi = sin_li * cos_omi + sin_omi * cos_li;
  669.             final double cos_li_m_omi = cos_li * cos_omi + sin_omi * sin_li;
  670.             final double cos_li_p_omi = cos_li * cos_omi - sin_omi * sin_li;
  671.             final double sin_2omi = 2. * sin_omi * cos_omi;
  672.             final double cos_2omi = 2. * cos_omi * cos_omi - 1.;
  673.             final double sin_2li_m_omi = sin_2li * cos_omi - sin_omi * cos_2li;
  674.             final double sin_2li_p_omi = sin_2li * cos_omi + sin_omi * cos_2li;
  675.             final double cos_2li_m_omi = cos_2li * cos_omi + sin_omi * sin_2li;
  676.             final double cos_2li_p_omi = cos_2li * cos_omi - sin_omi * sin_2li;
  677.             final double sin_2li_p_2omi = sin_2li * cos_2omi + sin_2omi * cos_2li;
  678.             final double cos_2li_p_2omi = cos_2li * cos_2omi - sin_2omi * sin_2li;
  679.             final double sin_2omi_p_li = sin_li * cos_2omi + sin_2omi * cos_li;
  680.             final double cos_2omi_p_li = cos_li * cos_2omi - sin_2omi * sin_li;
  681.             final double term1a = d2201 * (sin_2omi_p_li * C_G22 - cos_2omi_p_li * S_G22) +
  682.                                   d2211 * (sin_li * C_G22 - cos_li * S_G22) +
  683.                                   d3210 * (sin_li_p_omi * C_G32 - cos_li_p_omi * S_G32) +
  684.                                   d3222 * (sin_li_m_omi * C_G32 - cos_li_m_omi * S_G32) +
  685.                                   d5220 * (sin_li_p_omi * C_G52 - cos_li_p_omi * S_G52) +
  686.                                   d5232 * (sin_li_m_omi * C_G52 - cos_li_m_omi * S_G52);
  687.             final double term2a = d4410 * (sin_2li_p_2omi * C_G44 - cos_2li_p_2omi * S_G44) +
  688.                                   d4422 * (sin_2li * C_G44 - cos_2li * S_G44) +
  689.                                   d5421 * (sin_2li_p_omi * C_G54 - cos_2li_p_omi * S_G54) +
  690.                                   d5433 * (sin_2li_m_omi * C_G54 - cos_2li_m_omi * S_G54);
  691.             final double term1b = d2201 * (cos_2omi_p_li * C_G22 + sin_2omi_p_li * S_G22) +
  692.                                   d2211 * (cos_li * C_G22 + sin_li * S_G22) +
  693.                                   d3210 * (cos_li_p_omi * C_G32 + sin_li_p_omi * S_G32) +
  694.                                   d3222 * (cos_li_m_omi * C_G32 + sin_li_m_omi * S_G32) +
  695.                                   d5220 * (cos_li_p_omi * C_G52 + sin_li_p_omi * S_G52) +
  696.                                   d5232 * (cos_li_m_omi * C_G52 + sin_li_m_omi * S_G52);
  697.             final double term2b = 2.0 * (d4410 * (cos_2li_p_2omi * C_G44 + sin_2li_p_2omi * S_G44) +
  698.                                          d4422 * (cos_2li * C_G44 + sin_2li * S_G44) +
  699.                                          d5421 * (cos_2li_p_omi * C_G54 + sin_2li_p_omi * S_G54) +
  700.                                          d5433 * (cos_2li_m_omi * C_G54 + sin_2li_m_omi * S_G54));

  702.             derivs[0] = term1a + term2a;
  703.             derivs[1] = term1b + term2b;

  705.         }
  706.     }

  708. }
Created with JaCoCo 0.8.6.202009150832