コード例 #1
0
ファイル: PlanetEphem.cs プロジェクト: Astrarium/Astrarium
        /// <summary>
        /// Calculates visible appearance of planet for given date.
        /// </summary>
        /// <param name="jd">Julian day</param>
        /// <param name="planet">Planet number to calculate appearance, 1 = Mercury, 2 = Venus and etc.</param>
        /// <param name="eq">Equatorial coordinates of the planet</param>
        /// <param name="distance">Distance from the planet to the Earth</param>
        /// <returns>Appearance parameters of the planet</returns>
        /// <remarks>
        /// This method is based on book "Practical Ephemeris Calculations", Montenbruck.
        /// See topic 6.4, pp. 88-92.
        /// </remarks>
        public static PlanetAppearance PlanetAppearance(double jd, int planet, CrdsEquatorial eq, double distance)
        {
            PlanetAppearance a = new PlanetAppearance();

            double d = jd - 2451545.0;
            double T = d / 36525.0;

            // coordinates of the point to which the north pole of the planet is pointing.
            CrdsEquatorial eq0 = new CrdsEquatorial();

            eq0.Alpha = Angle.To360(cAlpha0[planet - 1][0] + cAlpha0[planet - 1][1] * T + cAlpha0[planet - 1][2] * T);
            eq0.Delta = cDelta0[planet - 1][0] + cDelta0[planet - 1][1] * T + cDelta0[planet - 1][2] * T;

            // take light time effect into account
            d -= PlanetPositions.LightTimeEffect(distance);
            T  = d / 36525.0;

            // position of null meridian
            double W = Angle.To360(cW[planet - 1][0] + cW[planet - 1][1] * d + cW[planet - 1][2] * T);

            double delta   = Angle.ToRadians(eq.Delta);
            double delta0  = Angle.ToRadians(eq0.Delta);
            double dAlpha0 = Angle.ToRadians(eq0.Alpha - eq.Alpha);

            double sinD = -Math.Sin(delta0) * Math.Sin(delta) - Math.Cos(delta0) * Math.Cos(delta) * Math.Cos(dAlpha0);

            // planetographic latitude of the Earth
            a.D = Angle.ToDegrees(Math.Asin(sinD));

            double cosD = Math.Cos(Angle.ToRadians(a.D));

            double sinP = Math.Cos(delta0) * Math.Sin(dAlpha0) / cosD;
            double cosP = (Math.Sin(delta0) * Math.Cos(delta) - Math.Cos(delta0) * Math.Sin(delta) * Math.Cos(dAlpha0)) / cosD;

            // position angle of the axis
            a.P = Angle.To360(Angle.ToDegrees(Math.Atan2(sinP, cosP)));

            double sinK = (-Math.Cos(delta0) * Math.Sin(delta) + Math.Sin(delta0) * Math.Cos(delta) * Math.Cos(dAlpha0)) / cosD;

            double cosK = Math.Cos(delta) * Math.Sin(dAlpha0) / cosD;

            double K = Angle.ToDegrees(Math.Atan2(sinK, cosK));

            // planetographic longitude of the central meridian
            a.CM = planet == 5 ?
                   JupiterCM2(jd) :
                   Angle.To360(Math.Sign(W) * (W - K));

            return(a);
        }
コード例 #2
0
ファイル: GalileanMoons.cs プロジェクト: Astrarium/Astrarium
        public static CrdsRectangular[,] Positions(double jd, CrdsHeliocentrical earth, CrdsHeliocentrical jupiter)
        {
            CrdsRectangular[,] positions = new CrdsRectangular[4, 2];

            // distance from Earth to Jupiter
            double distance = jupiter.ToRectangular(earth).ToEcliptical().Distance;

            // light-time effect
            double tau = PlanetPositions.LightTimeEffect(distance);

            // time, in days, since calculation epoch, with respect of light-time effect
            double t = jd - 2443000.5 - tau;

            double[] l_deg = new double[5];
            l_deg[1] = 106.07719 + 203.488955790 * t;
            l_deg[2] = 175.73161 + 101.374724735 * t;
            l_deg[3] = 120.55883 + 50.317609207 * t;
            l_deg[4] = 84.44459 + 21.571071177 * t;

            double[] l = new double[5];
            for (int i = 0; i < 5; i++)
            {
                l[i] = ToRadians(l_deg[i]);
            }

            double[] pi = new double[5];
            pi[1] = ToRadians(To360(97.0881 + 0.16138586 * t));
            pi[2] = ToRadians(To360(154.8663 + 0.04726307 * t));
            pi[3] = ToRadians(To360(188.1840 + 0.00712734 * t));
            pi[4] = ToRadians(To360(335.2868 + 0.00184000 * t));

            double[] w = new double[5];
            w[1] = ToRadians(312.3346 - 0.13279386 * t);
            w[2] = ToRadians(100.4411 - 0.03263064 * t);
            w[3] = ToRadians(119.1942 - 0.00717703 * t);
            w[4] = ToRadians(322.6186 - 0.00175934 * t);

            // Principal inequality in the longitude of Jupiter:
            double GAMMA = 0.33033 * Sin(ToRadians(163.679 + 0.0010512 * t)) +
                           0.03439 * Sin(ToRadians(34.486 - 0.0161731 * t));

            // Phase of small libraton:
            double PHI_lambda = ToRadians(199.6766 + 0.17379190 * t);

            // Longitude of the node of the equator of Jupiter on the ecliptic:
            double psi = ToRadians(316.5182 - 0.00000208 * t);

            // Mean anomalies of Jupiter and Saturn:
            double G  = ToRadians(30.23756 + 0.0830925701 * t + GAMMA);
            double G_ = ToRadians(31.97853 + 0.0334597339 * t);

            // Longitude of the perihelion of Jupiter:
            double Pi = ToRadians(13.469942);

            double[] SIGMA = new double[5];

            SIGMA[1] =
                0.47259 * Sin(2 * (l[1] - l[2])) +
                -0.03478 * Sin(pi[3] - pi[4]) +
                0.01081 * Sin(l[2] - 2 * l[3] + pi[3]) +
                0.00738 * Sin(PHI_lambda) +
                0.00713 * Sin(l[2] - 2 * l[3] + pi[2]) +
                -0.00674 * Sin(pi[1] + pi[3] - 2 * Pi - 2 * G) +
                0.00666 * Sin(l[2] - 2 * l[3] + pi[4]) +
                0.00445 * Sin(l[1] - pi[3]) +
                -0.00354 * Sin(l[1] - l[2]) +
                -0.00317 * Sin(2 * psi - 2 * Pi) +
                0.00265 * Sin(l[1] - pi[4]) +
                -0.00186 * Sin(G) +
                0.00162 * Sin(pi[2] - pi[3]) +
                0.00158 * Sin(4 * (l[1] - l[2])) +
                -0.00155 * Sin(l[1] - l[3]) +
                -0.00138 * Sin(psi + w[3] - 2 * Pi - 2 * G) +
                -0.00115 * Sin(2 * (l[1] - 2 * l[2] + w[2])) +
                0.00089 * Sin(pi[2] - pi[4]) +
                0.00085 * Sin(l[1] + pi[3] - 2 * Pi - 2 * G) +
                0.00083 * Sin(w[2] - w[3]) +
                0.00053 * Sin(psi - w[2]);
            SIGMA[2] =
                1.06476 * Sin(2 * (l[2] - l[3])) +
                0.04256 * Sin(l[1] - 2 * l[2] + pi[3]) +
                0.03581 * Sin(l[2] - pi[3]) +
                0.02395 * Sin(l[1] - 2 * l[2] + pi[4]) +
                0.01984 * Sin(l[2] - pi[4]) +
                -0.01778 * Sin(PHI_lambda) +
                0.01654 * Sin(l[2] - pi[2]) +
                0.01334 * Sin(l[2] - 2 * l[3] + pi[2]) +
                0.01294 * Sin(pi[3] - pi[4]) +
                -0.01142 * Sin(l[2] - l[3]) +
                -0.01057 * Sin(G) +
                -0.00775 * Sin(2 * (psi - Pi)) +
                0.00524 * Sin(2 * (l[1] - l[2])) +
                -0.00460 * Sin(l[1] - l[3]) +
                0.00316 * Sin(psi - 2 * G + w[3] - 2 * Pi) +
                -0.00203 * Sin(pi[1] + pi[3] - 2 * Pi - 2 * G) +
                0.00146 * Sin(psi - w[3]) +
                -0.00145 * Sin(2 * G) +
                0.00125 * Sin(psi - w[4]) +
                -0.00115 * Sin(l[1] - 2 * l[3] + pi[3]) +
                -0.00094 * Sin(2 * (l[2] - w[2])) +
                0.00086 * Sin(2 * (l[1] - 2 * l[2] + w[2])) +
                -0.00086 * Sin(5 * G_ - 2 * G + ToRadians(52.225)) +
                -0.00078 * Sin(l[2] - l[4]) +
                -0.00064 * Sin(3 * l[3] - 7 * l[4] + 4 * pi[4]) +
                0.00064 * Sin(pi[1] - pi[4]) +
                -0.00063 * Sin(l[1] - 2 * l[3] + pi[4]) +
                0.00058 * Sin(w[3] - w[4]) +
                0.00056 * Sin(2 * (psi - Pi - G)) +
                0.00056 * Sin(2 * (l[2] - l[4])) +
                0.00055 * Sin(2 * (l[1] - l[3])) +
                0.00052 * Sin(3 * l[3] - 7 * l[4] + pi[3] + 3 * pi[4]) +
                -0.00043 * Sin(l[1] - pi[3]) +
                0.00041 * Sin(5 * (l[2] - l[3])) +
                0.00041 * Sin(pi[4] - Pi) +
                0.00032 * Sin(w[2] - w[3]) +
                0.00032 * Sin(2 * (l[3] - G - Pi));
            SIGMA[3] =
                0.16490 * Sin(l[3] - pi[3]) +
                0.09081 * Sin(l[3] - pi[4]) +
                -0.06907 * Sin(l[2] - l[3]) +
                0.03784 * Sin(pi[3] - pi[4]) +
                0.01846 * Sin(2 * (l[3] - l[4])) +
                -0.01340 * Sin(G) +
                -0.01014 * Sin(2 * (psi - Pi)) +
                0.00704 * Sin(l[2] - 2 * l[3] + pi[3]) +
                -0.00620 * Sin(l[2] - 2 * l[3] + pi[2]) +
                -0.00541 * Sin(l[3] - l[4]) +
                0.00381 * Sin(l[2] - 2 * l[3] + pi[4]) +
                0.00235 * Sin(psi - w[3]) +
                0.00198 * Sin(psi - w[4]) +
                0.00176 * Sin(PHI_lambda) +
                0.00130 * Sin(3 * (l[3] - l[4])) +
                0.00125 * Sin(l[1] - l[3]) +
                -0.00119 * Sin(5 * G_ - 2 * G + ToRadians(52.225)) +
                0.00109 * Sin(l[1] - l[2]) +
                -0.00100 * Sin(3 * l[3] - 7 * l[4] + 4 * pi[4]) +
                0.00091 * Sin(w[3] - w[4]) +
                0.00080 * Sin(3 * l[3] - 7 * l[4] + pi[3] + 3 * pi[4]) +
                -0.00075 * Sin(2 * l[2] - 3 * l[3] + pi[3]) +
                0.00072 * Sin(pi[1] + pi[3] - 2 * Pi - 2 * G) +
                0.00069 * Sin(pi[4] - Pi) +
                -0.00058 * Sin(2 * l[3] - 3 * l[4] + pi[4]) +
                -0.00057 * Sin(l[3] - 2 * l[4] + pi[4]) +
                0.00056 * Sin(l[3] + pi[3] - 2 * Pi - 2 * G) +
                -0.00052 * Sin(l[2] - 2 * l[3] + pi[1]) +
                -0.00050 * Sin(pi[2] - pi[3]) +
                0.00048 * Sin(l[3] - 2 * l[4] + pi[3]) +
                -0.00045 * Sin(2 * l[2] - 3 * l[3] + pi[4]) +
                -0.00041 * Sin(pi[2] - pi[4]) +
                -0.00038 * Sin(2 * G) +
                -0.00037 * Sin(pi[3] - pi[4] + w[3] - w[4]) +
                -0.00032 * Sin(3 * l[3] - 7 * l[4] + 2 * pi[3] + 2 * pi[4]) +
                0.00030 * Sin(4 * (l[3] - l[4])) +
                0.00029 * Sin(l[3] + pi[4] - 2 * Pi - 2 * G) +
                -0.00028 * Sin(w[3] + psi - 2 * Pi - 2 * G) +
                0.00026 * Sin(l[3] - Pi - G) +
                0.00024 * Sin(l[2] - 3 * l[3] + 2 * l[4]) +
                0.00021 * Sin(l[3] - Pi - G) +
                -0.00021 * Sin(l[3] - pi[2]) +
                0.00017 * Sin(2 * (l[3] - pi[3]));
            SIGMA[4] =
                0.84287 * Sin(l[4] - pi[4]) +
                0.03431 * Sin(pi[4] - pi[3]) +
                -0.03305 * Sin(2 * (psi - Pi)) +
                -0.03211 * Sin(G) +
                -0.01862 * Sin(l[4] - pi[3]) +
                0.01186 * Sin(psi - w[4]) +
                0.00623 * Sin(l[4] + pi[4] - 2 * G - 2 * Pi) +
                0.00387 * Sin(2 * (l[4] - pi[4])) +
                -0.00284 * Sin(5 * G_ - 2 * G + ToRadians(52.225)) +
                -0.00234 * Sin(2 * (psi - pi[4])) +
                -0.00223 * Sin(l[3] - l[4]) +
                -0.00208 * Sin(l[4] - Pi) +
                0.00178 * Sin(psi + w[4] - 2 * pi[4]) +
                0.00134 * Sin(pi[4] - Pi) +
                0.00125 * Sin(2 * (l[4] - G - Pi)) +
                -0.00117 * Sin(2 * G) +
                -0.00112 * Sin(2 * (l[3] - l[4])) +
                0.00107 * Sin(3 * l[3] - 7 * l[4] + 4 * pi[4]) +
                0.00102 * Sin(l[4] - G - Pi) +
                0.00096 * Sin(2 * l[4] - psi - w[4]) +
                0.00087 * Sin(2 * (psi - w[4])) +
                -0.00085 * Sin(3 * l[3] - 7 * l[4] + pi[3] + 3 * pi[4]) +
                0.00085 * Sin(l[3] - 2 * l[4] + pi[4]) +
                -0.00081 * Sin(2 * (l[4] - psi)) +
                0.00071 * Sin(l[4] + pi[4] - 2 * Pi - 3 * G) +
                0.00061 * Sin(l[1] - l[4]) +
                -0.00056 * Sin(psi - w[3]) +
                -0.00054 * Sin(l[3] - 2 * l[4] + pi[3]) +
                0.00051 * Sin(l[2] - l[4]) +
                0.00042 * Sin(2 * (psi - G - Pi)) +
                0.00039 * Sin(2 * (pi[4] - w[4])) +
                0.00036 * Sin(psi + Pi - pi[4] - w[4]) +
                0.00035 * Sin(2 * G_ - G + ToRadians(188.37)) +
                -0.00035 * Sin(l[4] - pi[4] + 2 * Pi - 2 * psi) +
                -0.00032 * Sin(l[4] + pi[4] - 2 * Pi - G) +
                0.00030 * Sin(2 * G_ - 2 * G + ToRadians(149.15)) +
                0.00029 * Sin(3 * l[3] - 7 * l[4] + 2 * pi[3] + 2 * pi[4]) +
                0.00028 * Sin(l[4] - pi[4] + 2 * psi - 2 * Pi) +
                -0.00028 * Sin(2 * (l[4] - w[4])) +
                -0.00027 * Sin(pi[3] - pi[4] + w[3] - w[4]) +
                -0.00026 * Sin(5 * G_ - 3 * G + ToRadians(188.37)) +
                0.00025 * Sin(w[4] - w[3]) +
                -0.00025 * Sin(l[2] - 3 * l[3] + 2 * l[4]) +
                -0.00023 * Sin(3 * (l[3] - l[4])) +
                0.00021 * Sin(2 * l[4] - 2 * Pi - 3 * G) +
                -0.00021 * Sin(2 * l[3] - 3 * l[4] + pi[4]) +
                0.00019 * Sin(l[4] - pi[4] - G) +
                -0.00019 * Sin(2 * l[4] - pi[3] - pi[4]) +
                -0.00018 * Sin(l[4] - pi[4] + G) +
                -0.00016 * Sin(l[4] + pi[3] - 2 * Pi - 2 * G);

            // True longitudes of the sattelites:
            double[] L = new double[5];
            for (int i = 0; i < 5; i++)
            {
                L[i]     = ToRadians(To360(l_deg[i] + SIGMA[i]));
                SIGMA[i] = ToRadians(SIGMA[i]);
            }

            double[] BB = new double[5];

            BB[1] = Atan(
                0.0006393 * Sin(L[1] - w[1]) +
                0.0001825 * Sin(L[1] - w[2]) +
                0.0000329 * Sin(L[1] - w[3]) +
                -0.0000311 * Sin(L[1] - psi) +
                0.0000093 * Sin(L[1] - w[4]) +
                0.0000075 * Sin(3 * L[1] - 4 * l[2] - 1.9927 * SIGMA[1] + w[2]) +
                0.0000046 * Sin(L[1] + psi - 2 * Pi - 2 * G));

            BB[2] = Atan(
                0.0081004 * Sin(L[2] - w[2]) +
                0.0004512 * Sin(L[2] - w[3]) +
                -0.0003284 * Sin(L[2] - psi) +
                0.0001160 * Sin(L[2] - w[4]) +
                0.0000272 * Sin(l[1] - 2 * l[3] + 1.0146 * SIGMA[2] + w[2]) +
                -0.0000144 * Sin(L[2] - w[1]) +
                0.0000143 * Sin(L[2] + psi - 2 * Pi - 2 * G) +
                0.0000035 * Sin(L[2] - psi + G) +
                -0.0000028 * Sin(l[1] - 2 * l[3] + 1.0146 * SIGMA[2] + w[3]));
            BB[3] = Atan(
                0.0032402 * Sin(L[3] - w[3]) +
                -0.0016911 * Sin(L[3] - psi) +
                0.0006847 * Sin(L[3] - w[4]) +
                -0.0002797 * Sin(L[3] - w[2]) +
                0.0000321 * Sin(L[3] + psi - 2 * Pi - 2 * G) +
                0.0000051 * Sin(L[3] - psi + G) +
                -0.0000045 * Sin(L[3] - psi - G) +
                -0.0000045 * Sin(L[3] + psi - 2 * Pi) +
                0.0000037 * Sin(L[3] + psi - 2 * Pi - 3 * G) +
                0.0000030 * Sin(2 * l[2] - 3 * L[3] + 4.03 * SIGMA[3] + w[2]) +
                -0.0000021 * Sin(2 * l[2] - 3 * L[3] + 4.03 * SIGMA[3] + w[3]));

            BB[4] = Atan(
                -0.0076579 * Sin(L[4] - psi) +
                0.0044134 * Sin(L[4] - w[4]) +
                -0.0005112 * Sin(L[4] - w[3]) +
                0.0000773 * Sin(L[4] + psi - 2 * Pi - 2 * G) +
                0.0000104 * Sin(L[4] - psi + G) +
                -0.0000102 * Sin(L[4] - psi - G) +
                0.0000088 * Sin(L[4] + psi - 2 * Pi - 3 * G) +
                -0.0000038 * Sin(L[4] + psi - 2 * Pi - G));

            double[] R = new double[5];
            R[1] =
                5.90569 * (1 + (-0.0041339 * Cos(2 * (l[1] - l[2])) +
                                -0.0000387 * Cos(l[1] - pi[3]) +
                                -0.0000214 * Cos(l[1] - pi[4]) +
                                0.0000170 * Cos(l[1] - l[2]) +
                                -0.0000131 * Cos(4 * (l[1] - l[2])) +
                                0.0000106 * Cos(l[1] - l[3]) +
                                -0.0000066 * Cos(l[1] + pi[3] - 2 * Pi - 2 * G)));
            R[2] =
                9.39657 * (1 + (0.0093848 * Cos(l[1] - l[2]) +
                                -0.0003116 * Cos(l[2] - pi[3]) +
                                -0.0001744 * Cos(l[2] - pi[4]) +
                                -0.0001442 * Cos(l[2] - pi[2]) +
                                0.0000553 * Cos(l[2] - l[3]) +
                                0.0000523 * Cos(l[1] - l[3]) +
                                -0.0000290 * Cos(2 * (l[1] - l[2])) +
                                0.0000164 * Cos(2 * (l[2] - w[2])) +
                                0.0000107 * Cos(l[1] - 2 * l[3] + pi[3]) +
                                -0.0000102 * Cos(l[2] - pi[1]) +
                                -0.0000091 * Cos(2 * (l[1] - l[3]))));
            R[3] =
                14.98832 * (1 + (-0.0014388 * Cos(l[3] - pi[3]) +
                                 -0.0007919 * Cos(l[3] - pi[4]) +
                                 0.0006342 * Cos(l[2] - l[3]) +
                                 -0.0001761 * Cos(2 * (l[3] - l[4])) +
                                 0.0000294 * Cos(l[3] - l[4]) +
                                 -0.0000156 * Cos(3 * (l[3] - l[4])) +
                                 0.0000156 * Cos(l[1] - l[3]) +
                                 -0.0000153 * Cos(l[1] - l[2]) +
                                 0.0000070 * Cos(2 * l[2] - 3 * l[3] + pi[3]) +
                                 -0.0000051 * Cos(l[3] + pi[3] - 2 * Pi - 2 * G)));
            R[4] =
                26.36273 * (1 + (-0.0073546 * Cos(l[4] - pi[4]) +
                                 0.0001621 * Cos(l[4] - pi[3]) +
                                 0.0000974 * Cos(l[3] - l[4]) +
                                 -0.0000543 * Cos(l[4] + pi[4] - 2 * Pi - 2 * G) +
                                 -0.0000271 * Cos(2 * (l[4] - pi[4])) +
                                 0.0000182 * Cos(l[4] - Pi) +
                                 0.0000177 * Cos(2 * (l[3] - l[4])) +
                                 -0.0000167 * Cos(2 * l[4] - psi - w[4]) +
                                 0.0000167 * Cos(psi - w[4]) +
                                 -0.0000155 * Cos(2 * (l[4] - Pi - G)) +
                                 0.0000142 * Cos(2 * (l[4] - psi)) +
                                 0.0000105 * Cos(l[1] - l[4]) +
                                 0.0000092 * Cos(l[2] - l[4]) +
                                 -0.0000089 * Cos(l[4] - Pi - G) +
                                 -0.0000062 * Cos(l[4] + pi[4] - 2 * Pi - 3 * G) +
                                 0.0000048 * Cos(2 * (l[4] - w[4]))));

            double T0 = (jd - 2433282.423) / 36525.0;
            double P  = ToRadians(1.3966626 * T0 + 0.0003088 * T0 * T0);

            for (int i = 0; i < 5; i++)
            {
                L[i] += P;
            }
            psi += P;

            double T = (jd - 2415020.5) / 36525;
            double I = ToRadians(3.120262 + 0.0006 * T);

            double[] X = new double[6];
            double[] Y = new double[6];
            double[] Z = new double[6];

            for (int i = 1; i < 5; i++)
            {
                X[i] = R[i] * Cos(L[i] - psi) * Cos(BB[i]);
                Y[i] = R[i] * Sin(L[i] - psi) * Cos(BB[i]);
                Z[i] = R[i] * Sin(BB[i]);
            }

            X[5] = 0; Y[5] = 0; Z[5] = 1;

            double[] A1 = new double[6];
            double[] B1 = new double[6];
            double[] C1 = new double[6];

            for (int i = 1; i < 6; i++)
            {
                A1[i] = X[i];
                B1[i] = Y[i] * Cos(I) - Z[i] * Sin(I);
                C1[i] = Y[i] * Sin(I) + Z[i] * Cos(I);
            }

            double[] A2 = new double[6];
            double[] B2 = new double[6];
            double[] C2 = new double[6];

            double T1 = (jd - 2451545.0) / 36525;
            double T2 = T1 * T1;
            double T3 = T2 * T1;

            double OMEGA = 100.464407 + 1.0209774 * T1 + 0.00040315 * T2 + 0.000000404 * T3;

            OMEGA = ToRadians(OMEGA);

            double Inc = 1.303267 - 0.0054965 * T1 + 0.00000466 * T2 + 0.000000002 * T3;

            Inc = ToRadians(Inc);

            double PHI = psi - OMEGA;

            for (int i = 5; i >= 1; i--)
            {
                A2[i] = A1[i] * Cos(PHI) - B1[i] * Sin(PHI);
                B2[i] = A1[i] * Sin(PHI) + B1[i] * Cos(PHI);
                C2[i] = C1[i];
            }

            double[] A3 = new double[6];
            double[] B3 = new double[6];
            double[] C3 = new double[6];

            for (int i = 5; i >= 1; i--)
            {
                A3[i] = A2[i];
                B3[i] = B2[i] * Cos(Inc) - C2[i] * Sin(Inc);
                C3[i] = B2[i] * Sin(Inc) + C2[i] * Cos(Inc);
            }

            double[] A4 = new double[6];
            double[] B4 = new double[6];
            double[] C4 = new double[6];

            for (int i = 5; i >= 1; i--)
            {
                A4[i] = A3[i] * Cos(OMEGA) - B3[i] * Sin(OMEGA);
                B4[i] = A3[i] * Sin(OMEGA) + B3[i] * Cos(OMEGA);
                C4[i] = C3[i];
            }

            double[] A5 = new double[6];
            double[] B5 = new double[6];
            double[] C5 = new double[6];

            for (int m = 0; m < 2; m++)
            {
                // "0" for shadows
                double Radius = m == 0 ? earth.R : 0;

                // Rectangular geocentric ecliptic coordinates of Jupiter:
                double x = jupiter.R * Cos(ToRadians(jupiter.B)) * Cos(ToRadians(jupiter.L)) + Radius * Cos(ToRadians(earth.L + 180));
                double y = jupiter.R * Cos(ToRadians(jupiter.B)) * Sin(ToRadians(jupiter.L)) + Radius * Sin(ToRadians(earth.L + 180));
                double z = jupiter.R * Sin(ToRadians(jupiter.B)) + Radius * Sin(ToRadians(-earth.B));

                double Delta  = Sqrt(x * x + y * y + z * z);
                double LAMBDA = Atan2(y, x);
                double alpha  = Atan(z / Sqrt(x * x + y * y));

                for (int i = 5; i >= 1; i--)
                {
                    A5[i] = A4[i] * Sin(LAMBDA) - B4[i] * Cos(LAMBDA);
                    B5[i] = A4[i] * Cos(LAMBDA) + B4[i] * Sin(LAMBDA);
                    C5[i] = C4[i];
                }

                double[] A6 = new double[6];
                double[] B6 = new double[6];
                double[] C6 = new double[6];

                for (int i = 5; i >= 1; i--)
                {
                    A6[i] = A5[i];
                    B6[i] = C5[i] * Sin(alpha) + B5[i] * Cos(alpha);
                    C6[i] = C5[i] * Cos(alpha) - B5[i] * Sin(alpha);
                }

                double D = Atan2(A6[5], C6[5]);

                CrdsRectangular[] rectangular = new CrdsRectangular[4];

                for (int i = 0; i < 4; i++)
                {
                    rectangular[i] = new CrdsRectangular(
                        A6[i + 1] * Cos(D) - C6[i + 1] * Sin(D),
                        A6[i + 1] * Sin(D) + C6[i + 1] * Cos(D),
                        B6[i + 1]
                        );
                }

                double[] K = { 17295, 21819, 27558, 36548 };

                for (int i = 0; i < 4; i++)
                {
                    rectangular[i].X += Abs(rectangular[i].Z) / K[i] * Sqrt(1 - Pow(rectangular[i].X / R[i + 1], 2));
                }

                for (int i = 0; i < 4; i++)
                {
                    double W = Delta / (Delta + rectangular[i].Z / 2095.0);
                    rectangular[i].X *= W;
                    rectangular[i].Y *= W;
                }

                for (int i = 0; i < 4; i++)
                {
                    positions[i, m] = rectangular[i];
                }
            }

            return(positions);
        }
コード例 #3
0
ファイル: NeptunianMoons.cs プロジェクト: silas1037/Astrarium
        /// <summary>
        /// Calculates ecliptical coordinates of Triton, largest moon of Neptune.
        /// </summary>
        /// <param name="jd">Julian Day of calculation</param>
        /// <param name="neptune">Ecliptical coordinates of Neptune for the Julian Day specified.</param>
        /// <returns>Ecliptical coordinates of Triton for specified date.</returns>
        /// <remarks>
        ///
        /// The method is based on following works:
        ///
        /// 1. Harris, A.W. (1984), "Physical Properties of Neptune and Triton Inferred from the Orbit of Triton" NASA CP-2330, pages 357-373:
        ///    http://articles.adsabs.harvard.edu/cgi-bin/nph-iarticle_query?1984NASCP2330..357H&defaultprint=YES&filetype=.pdf
        ///
        /// 2. Seidelmann, P. K.: Explanatory Supplement to The Astronomical Almanac,
        ///    University Science Book, Mill Valley (California), 1992,
        ///    Chapter 6 "Orbital Ephemerides and Rings of Satellites", page 373, 6.61-1 Triton
        ///    https://archive.org/download/131123ExplanatorySupplementAstronomicalAlmanac/131123-explanatory-supplement-astronomical-almanac.pdf
        ///
        /// </remarks>
        private static CrdsEcliptical TritonPosition(double jd, CrdsEcliptical neptune)
        {
            NutationElements ne      = Nutation.NutationElements(jd);
            double           epsilon = Date.TrueObliquity(jd, ne.deltaEpsilon);

            // convert current coordinates to J1950 epoch, as algorithm requires
            CrdsEquatorial       eq            = neptune.ToEquatorial(epsilon);
            PrecessionalElements pe1950        = Precession.ElementsFK5(jd, Date.EPOCH_J1950);
            CrdsEquatorial       eqNeptune1950 = Precession.GetEquatorialCoordinates(eq, pe1950);

            const double t0 = 2433282.5;       // 1.0 Jan 1950
            const double a  = 0.0023683;       // semimajor axis of Triton, in a.u.

            const double n       = 61.2588532; // nodal mean motion, degrees per day
            const double lambda0 = 200.913;    // longitude from ascending node through the invariable plane at epoch
            const double i       = 158.996;    // inclination of orbit to the invariable plane

            const double Omega0 = 151.401;     // angle from the intersection of invariable plane with the earth's
                                               // equatorial plane of 1950.0 to the ascending node
                                               // of the orbit through the invariable plane

            const double OmegaDot = 0.57806;   // nodal precision rate, degrees per year

            // Calculate J2000.0 RA and Declination of the pole of the invariable plane
            // These formulae are taken from the book:
            // Seidelmann, P. K.: Explanatory Supplement to The Astronomical Almanac,
            // University Science Book, Mill Valley (California), 1992,
            // Chapter 6 "Orbital Ephemerides and Rings of Satellites", page 373, 6.61-1 Triton
            double T  = (jd - 2451545.0) / 36525.0;
            double N  = ToRadians(359.28 + 54.308 * T);
            double ap = 298.72 + 2.58 * Sin(N) - 0.04 * Sin(2 * N);
            double dp = 42.63 - 1.90 * Cos(N) + 0.01 * Cos(2 * N);

            // Convert pole coordinates to J1950
            CrdsEquatorial eqPole1950 = Precession.GetEquatorialCoordinates(new CrdsEquatorial(ap, dp), pe1950);

            ap = eqPole1950.Alpha;
            dp = eqPole1950.Delta;

            // take light-time effect into account
            double tau = PlanetPositions.LightTimeEffect(neptune.Distance);

            double lambda = To360(lambda0 + n * (jd - t0 - tau));
            double omega  = Omega0 + OmegaDot * (jd - t0 - tau) / 365.25;

            // cartesian state vector of Triton
            var r =
                Matrix.R3(ToRadians(-ap - 90)) *
                Matrix.R1(ToRadians(dp - 90)) *
                Matrix.R3(ToRadians(-omega)) *
                Matrix.R1(ToRadians(-i)) *
                new Matrix(new[, ] {
                { a *Cos(ToRadians(lambda)) }, { a *Sin(ToRadians(lambda)) }, { 0 }
            });

            // normalize by distance to Neptune
            r.Values[0, 0] /= neptune.Distance;
            r.Values[1, 0] /= neptune.Distance;
            r.Values[2, 0] /= neptune.Distance;

            // offsets vector
            var d =
                Matrix.R2(ToRadians(-eqNeptune1950.Delta)) *
                Matrix.R3(ToRadians(eqNeptune1950.Alpha)) *
                r;

            // radial component, positive away from observer
            // converted to degrees
            double x = ToDegrees(d.Values[0, 0]);

            // semimajor axis, expressed in degrees, as visible from Earth
            double theta = ToDegrees(Atan(a / neptune.Distance));

            // offsets values in degrees
            double dAlphaCosDelta = ToDegrees(d.Values[1, 0]);
            double dDelta         = ToDegrees(d.Values[2, 0]);

            double delta  = eqNeptune1950.Delta + dDelta;
            double dAlpha = dAlphaCosDelta / Cos(ToRadians(eqNeptune1950.Delta));
            double alpha  = eqNeptune1950.Alpha + dAlpha;

            CrdsEquatorial eqTriton1950 = new CrdsEquatorial(alpha, delta);

            // convert J1950 equatorial coordinates to current epoch
            // and to ecliptical
            PrecessionalElements pe        = Precession.ElementsFK5(Date.EPOCH_J1950, jd);
            CrdsEquatorial       eqTriton  = Precession.GetEquatorialCoordinates(eqTriton1950, pe);
            CrdsEcliptical       eclTriton = eqTriton.ToEcliptical(epsilon);

            // calculate distance to Earth
            eclTriton.Distance = neptune.Distance + x / theta * a;

            return(eclTriton);
        }
コード例 #4
0
ファイル: NeptunianMoons.cs プロジェクト: silas1037/Astrarium
        /// <summary>
        /// Calculates ecliptical coordinates of Nereid, the third-largest moon of Neptune.
        /// </summary>
        /// <param name="jd">Julian Day of calculation</param>
        /// <param name="neptune">Ecliptical coordinates of Neptune for the Julian Day specified.</param>
        /// <returns>Ecliptical coordinates of Nereid for specified date.</returns>
        /// <remarks>
        ///
        /// The method is based on work of F. Mignard (1981), "The Mean Elements of Nereid",
        /// The Astronomical Journal, Vol 86, Number 11, pages 1728-1729
        /// The work can be found by link: http://adsabs.harvard.edu/full/1981AJ.....86.1728M
        ///
        /// There are some changes from the original algorithm were made,
        /// to be compliant with ephemeris provided by Nasa JPL Horizons system (https://ssd.jpl.nasa.gov/?ephemerides):
        ///
        /// 1. Other value of mean motion (n) is used:
        ///    - original work : n = 0.999552
        ///    - implementation: n = 360.0 / 360.1362 (where 360.1362 is an orbital period)
        ///
        /// 2. Rotation around Z axis by angle OmegaN should by taken with NEGATIVE sign,
        ///    insted of POSITIVE sign in original work (possible typo?),
        ///    note the NEGATIVE sign for "Ne" angle (same meaning as "OmegaN" in original work) in the book:
        ///    Seidelmann, P. K.: Explanatory Supplement to The Astronomical Almanac,
        ///    University Science Book, Mill Valley (California), 1992,
        ///    Chapter 6 "Orbital Ephemerides and Rings of Satellites", page 376, formula 6.62-3
        ///
        /// </remarks>
        private static CrdsEcliptical NereidPosition(double jd, CrdsEcliptical neptune)
        {
            NutationElements ne      = Nutation.NutationElements(jd);
            double           epsilon = Date.TrueObliquity(jd, ne.deltaEpsilon);

            // convert current coordinates to J1950 epoch, as algorithm requires
            CrdsEquatorial       eq            = neptune.ToEquatorial(epsilon);
            PrecessionalElements pe1950        = Precession.ElementsFK5(jd, Date.EPOCH_J1950);
            CrdsEquatorial       eqNeptune1950 = Precession.GetEquatorialCoordinates(eq, pe1950);

            const double jd0 = 2433680.5;           // Initial Epoch: 3.0 Feb 1951

            const double a      = 0.036868;         // Semi-major axis, in a.u.
            const double e0     = 0.74515;          // Orbit eccentricity for jd0 epoch
            const double i0     = 10.041;           // Inclination of the orbit for jd0 epoch, in degrees
            const double Omega0 = 329.3;            // Longitude of the node of the orbit for jd0 epoch, in degrees
            const double M0     = 358.91;           // Mean anomaly for jd0 epoch, in degrees
            const double n      = 360.0 / 360.1362; // Mean motion, in degrees per day
            const double OmegaN = 3.552;            // Longitude of ascending node of the orbit of Neptune, for J1950.0 epoch, in degrees
            const double gamma  = 22.313;           // Inclination of the orbit of Neptune, for J1950.0 epoch, in degrees

            // take light-time effect into account
            double tau = PlanetPositions.LightTimeEffect(neptune.Distance);

            double t = jd - tau - jd0;          // in days
            double T = t / 36525.0;             // in Julian centuries

            double psi      = ToRadians(To360(282.9 + 2.68 * T));
            double twoTheta = ToRadians(To360(107.4 + 0.01196 * t));

            // Equation to found omega, argument of pericenter
            Func <double, double> omegaEquation = (om) => To360(282.9 + 2.68 * T - 19.25 * Sin(2 * psi) + 3.23 * Sin(4 * psi) - 0.725 * Sin(6 * psi) - 0.351 * Sin(twoTheta) - 0.7 * Sin(ToRadians(2 * om) - twoTheta)) - om;

            // Solve equation (find root: omega value)
            double omega = ToRadians(FindRoots(omegaEquation, 0, 360, 1e-8));

            // Find longitude of the node
            double Omega = Omega0 - 2.4 * T + 19.7 * Sin(2 * psi) - 3.3 * Sin(4 * psi) + 0.7 * Sin(6 * psi) + 0.357 * Sin(twoTheta) + 0.276 * Sin(2 * omega - twoTheta);

            // Find orbit eccentricity
            double e = e0 - 0.006 * Cos(2 * psi) + 0.0056 * Cos(2 * omega - twoTheta);

            // Find mean anomaly
            double M = To360(M0 + n * t - 0.38 * Sin(2 * psi) + 1.0 * Sin(2 * omega - twoTheta));

            // Find inclination
            double cosi = Cos(ToRadians(i0)) - 9.4e-3 * Cos(2 * psi);
            double i    = Acos(cosi);

            // Find eccentric anomaly by solving Kepler equation
            double E = SolveKepler(M, e);

            double X = a * (Cos(E) - e);
            double Y = a * Sqrt(1 - e * e) * Sin(E);

            Matrix d =
                Matrix.R2(ToRadians(-eqNeptune1950.Delta)) *
                Matrix.R3(ToRadians(eqNeptune1950.Alpha)) *
                Matrix.R3(ToRadians(-OmegaN)) *
                Matrix.R1(ToRadians(-gamma)) *
                Matrix.R3(ToRadians(-Omega)) *
                Matrix.R1(-i) *
                Matrix.R3(-omega) *
                new Matrix(new double[, ] {
                { X / neptune.Distance }, { Y / neptune.Distance }, { 0 }
            });

            // radial component, positive away from observer
            // converted to degrees
            double x = ToDegrees(d.Values[0, 0]);

            // offsets values in degrees
            double dAlphaCosDelta = ToDegrees(d.Values[1, 0]);
            double dDelta         = ToDegrees(d.Values[2, 0]);

            double delta  = eqNeptune1950.Delta + dDelta;
            double dAlpha = dAlphaCosDelta / Cos(ToRadians(eqNeptune1950.Delta));
            double alpha  = eqNeptune1950.Alpha + dAlpha;

            CrdsEquatorial eqNereid1950 = new CrdsEquatorial(alpha, delta);

            // convert J1950 equatorial coordinates to current epoch
            // and to ecliptical
            PrecessionalElements pe        = Precession.ElementsFK5(Date.EPOCH_J1950, jd);
            CrdsEquatorial       eqNereid  = Precession.GetEquatorialCoordinates(eqNereid1950, pe);
            CrdsEcliptical       eclNereid = eqNereid.ToEcliptical(epsilon);

            // semimajor axis, expressed in degrees, as visible from Earth
            double theta = ToDegrees(Atan(a / neptune.Distance));

            // calculate distance to Earth
            eclNereid.Distance = neptune.Distance + x / theta * a;

            return(eclNereid);
        }
コード例 #5
0
ファイル: MartianMoons.cs プロジェクト: silas1037/Astrarium
        public static CrdsRectangular[] Positions(double jd, CrdsHeliocentrical earth, CrdsHeliocentrical mars)
        {
            CrdsRectangular[] moons = new CrdsRectangular[MOONS_COUNT];

            // Rectangular topocentrical coordinates of Mars
            CrdsRectangular rectMars = mars.ToRectangular(earth);

            // Ecliptical coordinates of Mars
            CrdsEcliptical eclMars = rectMars.ToEcliptical();

            // Distance from Earth to Mars, in AU
            double distanceMars = eclMars.Distance;

            // light-time effect
            double tau = PlanetPositions.LightTimeEffect(distanceMars);

            // ESAPHODEI model
            double t = jd - 2451545.0 + 6491.5 - tau;

            GenerateMarsSatToVSOP87(t, ref mars_sat_to_vsop87);

            // Get rectangular (Mars-reffered) coordinates of moons
            CrdsRectangular[] esaphodeiRect = new CrdsRectangular[MOONS_COUNT];

            for (int body = 0; body < MOONS_COUNT; body++)
            {
                MarsSatBody bp = mars_sat_bodies[body];

                double[] elem = new double[6];
                for (int n = 0; n < 6; n++)
                {
                    elem[n] = bp.constants[n];
                }

                for (int j = 0; j < 2; j++)
                {
                    for (int i = bp.lists[j].size - 1; i >= 0; i--)
                    {
                        double d = bp.lists[j].terms[i].phase + t * bp.lists[j].terms[i].frequency;
                        elem[j] += bp.lists[j].terms[i].amplitude * Cos(d);
                    }
                }

                for (int j = 2; j < 4; j++)
                {
                    for (int i = bp.lists[j].size - 1; i >= 0; i--)
                    {
                        double d = bp.lists[j].terms[i].phase + t * bp.lists[j].terms[i].frequency;
                        elem[2 * j - 2] += bp.lists[j].terms[i].amplitude * Cos(d);
                        elem[2 * j - 1] += bp.lists[j].terms[i].amplitude * Sin(d);
                    }
                }

                elem[1] += (bp.l + bp.acc * t) * t;

                double[] x = new double[3];
                EllipticToRectangularA(mars_sat_bodies[body].mu, elem, ref x);


                esaphodeiRect[body] = new CrdsRectangular();

                esaphodeiRect[body].X = mars_sat_to_vsop87[0] * x[0]
                                        + mars_sat_to_vsop87[1] * x[1]
                                        + mars_sat_to_vsop87[2] * x[2];
                esaphodeiRect[body].Y = mars_sat_to_vsop87[3] * x[0]
                                        + mars_sat_to_vsop87[4] * x[1]
                                        + mars_sat_to_vsop87[5] * x[2];
                esaphodeiRect[body].Z = mars_sat_to_vsop87[6] * x[0]
                                        + mars_sat_to_vsop87[7] * x[1]
                                        + mars_sat_to_vsop87[8] * x[2];

                moons[body] = new CrdsRectangular(
                    rectMars.X + esaphodeiRect[body].X,
                    rectMars.Y + esaphodeiRect[body].Y,
                    rectMars.Z + esaphodeiRect[body].Z
                    );
            }

            return(moons);
        }
コード例 #6
0
        public static CrdsEcliptical Position(double jd, GenericSatelliteOrbit orbit, CrdsEcliptical planet)
        {
            NutationElements ne      = Nutation.NutationElements(jd);
            double           epsilon = Date.TrueObliquity(jd, ne.deltaEpsilon);

            // convert current coordinates to epoch, as algorithm requires
            CrdsEquatorial       eq            = planet.ToEquatorial(epsilon);
            PrecessionalElements peEpoch       = Precession.ElementsFK5(jd, Date.EPOCH_J2000);
            CrdsEquatorial       eqPlanetEpoch = Precession.GetEquatorialCoordinates(eq, peEpoch);

            // ecliptical pole
            CrdsEquatorial pole = new CrdsEcliptical(0, 90).ToEquatorial(epsilon);

            double distance0;
            double distance = planet.Distance;

            CrdsEcliptical eclSatellite;

            do
            {
                distance0 = distance;

                // take light-time effect into account
                double tau = PlanetPositions.LightTimeEffect(distance);

                double t = jd - tau - orbit.jd;

                double M = To360(orbit.M + orbit.n * t);

                double omega = To360(orbit.w + t * 360.0 / (orbit.Pw * 365.25));
                double node  = To360(orbit.Om + t * 360.0 / (orbit.POm * 365.25));

                // Find eccentric anomaly by solving Kepler equation
                double E = SolveKepler(M, orbit.e);

                double X = orbit.a * (Cos(E) - orbit.e);
                double Y = orbit.a * Sqrt(1 - orbit.e * orbit.e) * Sin(E);

                // cartesian state vector of satellite
                var d =
                    Matrix.R2(ToRadians(-eqPlanetEpoch.Delta)) *
                    Matrix.R3(ToRadians(eqPlanetEpoch.Alpha)) *
                    Matrix.R3(ToRadians(-pole.Alpha - 90)) *
                    Matrix.R1(ToRadians(pole.Delta - 90)) *
                    Matrix.R3(ToRadians(-node)) *
                    Matrix.R1(ToRadians(-orbit.i)) *
                    Matrix.R3(ToRadians(-omega)) *
                    new Matrix(new double[, ] {
                    { X / distance }, { Y / distance }, { 0 }
                });

                // radial component, positive away from observer
                // converted to degrees
                double x = ToDegrees(d.Values[0, 0]);

                // semimajor axis, expressed in degrees, as visible from Earth
                double theta = ToDegrees(Atan(orbit.a / distance));

                // offsets values in degrees
                double dAlphaCosDelta = ToDegrees(d.Values[1, 0]);
                double dDelta         = ToDegrees(d.Values[2, 0]);

                double delta  = eqPlanetEpoch.Delta + dDelta;
                double dAlpha = dAlphaCosDelta / Cos(ToRadians(delta));
                double alpha  = eqPlanetEpoch.Alpha + dAlpha;

                CrdsEquatorial eqSatelliteEpoch = new CrdsEquatorial(alpha, delta);

                // convert jd0 equatorial coordinates to current epoch
                // and to ecliptical
                PrecessionalElements pe          = Precession.ElementsFK5(Date.EPOCH_J2000, jd);
                CrdsEquatorial       eqSatellite = Precession.GetEquatorialCoordinates(eqSatelliteEpoch, pe);
                eclSatellite = eqSatellite.ToEcliptical(epsilon);

                // calculate distance to Earth
                distance = planet.Distance + x / theta * orbit.a;
            }while (Abs(distance - distance0) > 1e-6);

            eclSatellite.Distance = distance;

            return(eclSatellite);
        }
コード例 #7
0
ファイル: UranianMoons.cs プロジェクト: Astrarium/Astrarium
        public static CrdsRectangular[] Positions(double jd, CrdsHeliocentrical earth, CrdsHeliocentrical uranus)
        {
            CrdsRectangular[] moons = new CrdsRectangular[MOONS_COUNT];

            // Rectangular topocentrical coordinates of Uranus
            CrdsRectangular rectUranus = uranus.ToRectangular(earth);

            // Ecliptical coordinates of Uranus
            CrdsEcliptical eclUranus = rectUranus.ToEcliptical();

            // Distance from Earth to Uranus, in AU
            double distanceUranus = eclUranus.Distance;

            // light-time effect
            double tau = PlanetPositions.LightTimeEffect(distanceUranus);

            double t = jd - 2444239.5 - tau;

            double[] elem = new double[6 * MOONS_COUNT];
            double[] an   = new double[MOONS_COUNT];
            double[] ae   = new double[MOONS_COUNT];
            double[] ai   = new double[MOONS_COUNT];

            // Calculate GUST86 elements:

            for (int i = 0; i < 5; i++)
            {
                an[i] = IEEERemainder(fqn[i] * t + phn[i], 2 * PI);
                ae[i] = IEEERemainder(fqe[i] * t + phe[i], 2 * PI);
                ai[i] = IEEERemainder(fqi[i] * t + phi[i], 2 * PI);
            }

            elem[0 * 6 + 0] = 4.44352267
                              - Cos(an[0] - an[1] * 3.0 + an[2] * 2.0) * 3.492e-5
                              + Cos(an[0] * 2.0 - an[1] * 6.0 + an[2] * 4.0) * 8.47e-6
                              + Cos(an[0] * 3.0 - an[1] * 9.0 + an[2] * 6.0) * 1.31e-6
                              - Cos(an[0] - an[1]) * 5.228e-5
                              - Cos(an[0] * 2.0 - an[1] * 2.0) * 1.3665e-4;
            elem[0 * 6 + 1] =
                Sin(an[0] - an[1] * 3.0 + an[2] * 2.0) * .02547217
                - Sin(an[0] * 2.0 - an[1] * 6.0 + an[2] * 4.0) * .00308831
                - Sin(an[0] * 3.0 - an[1] * 9.0 + an[2] * 6.0) * 3.181e-4
                - Sin(an[0] * 4.0 - an[1] * 12 + an[2] * 8.0) * 3.749e-5
                - Sin(an[0] - an[1]) * 5.785e-5
                - Sin(an[0] * 2.0 - an[1] * 2.0) * 6.232e-5
                - Sin(an[0] * 3.0 - an[1] * 3.0) * 2.795e-5
                + t * 4.44519055 - .23805158;
            elem[0 * 6 + 2] = Cos(ae[0]) * .00131238
                              + Cos(ae[1]) * 7.181e-5
                              + Cos(ae[2]) * 6.977e-5
                              + Cos(ae[3]) * 6.75e-6
                              + Cos(ae[4]) * 6.27e-6
                              + Cos(an[0]) * 1.941e-4
                              - Cos(-an[0] + an[1] * 2.0) * 1.2331e-4
                              + Cos(an[0] * -2.0 + an[1] * 3.0) * 3.952e-5;
            elem[0 * 6 + 3] = Sin(ae[0]) * .00131238
                              + Sin(ae[1]) * 7.181e-5
                              + Sin(ae[2]) * 6.977e-5
                              + Sin(ae[3]) * 6.75e-6
                              + Sin(ae[4]) * 6.27e-6
                              + Sin(an[0]) * 1.941e-4
                              - Sin(-an[0] + an[1] * 2.0) * 1.2331e-4
                              + Sin(an[0] * -2.0 + an[1] * 3.0) * 3.952e-5;
            elem[0 * 6 + 4] = Cos(ai[0]) * .03787171
                              + Cos(ai[1]) * 2.701e-5
                              + Cos(ai[2]) * 3.076e-5
                              + Cos(ai[3]) * 1.218e-5
                              + Cos(ai[4]) * 5.37e-6;
            elem[0 * 6 + 4] = Sin(ai[0]) * .03787171
                              + Sin(ai[1]) * 2.701e-5
                              + Sin(ai[2]) * 3.076e-5
                              + Sin(ai[3]) * 1.218e-5
                              + Sin(ai[4]) * 5.37e-6;

            elem[1 * 6 + 0] = 2.49254257
                              + Cos(an[0] - an[1] * 3.0 + an[2] * 2.0) * 2.55e-6
                              - Cos(an[1] - an[2]) * 4.216e-5
                              - Cos(an[1] * 2.0 - an[2] * 2.0) * 1.0256e-4;
            elem[1 * 6 + 1] =
                -Sin(an[0] - an[1] * 3.0 + an[2] * 2.0) * .0018605
                + Sin(an[0] * 2.0 - an[1] * 6.0 + an[2] * 4.0) * 2.1999e-4
                + Sin(an[0] * 3.0 - an[1] * 9.0 + an[2] * 6.0) * 2.31e-5
                + Sin(an[0] * 4.0 - an[1] * 12 + an[2] * 8.0) * 4.3e-6
                - Sin(an[1] - an[2]) * 9.011e-5
                - Sin(an[1] * 2.0 - an[2] * 2.0) * 9.107e-5
                - Sin(an[1] * 3.0 - an[2] * 3.0) * 4.275e-5
                - Sin(an[1] * 2.0 - an[3] * 2.0) * 1.649e-5
                + t * 2.49295252 + 3.09804641;
            elem[1 * 6 + 2] = Cos(ae[0]) * -3.35e-6
                              + Cos(ae[1]) * .00118763
                              + Cos(ae[2]) * 8.6159e-4
                              + Cos(ae[3]) * 7.15e-5
                              + Cos(ae[4]) * 5.559e-5
                              - Cos(-an[1] + an[2] * 2.0) * 8.46e-5
                              + Cos(an[1] * -2.0 + an[2] * 3.0) * 9.181e-5
                              + Cos(-an[1] + an[3] * 2.0) * 2.003e-5
                              + Cos(an[1]) * 8.977e-5;
            elem[1 * 6 + 3] = Sin(ae[0]) * -3.35e-6
                              + Sin(ae[1]) * .00118763
                              + Sin(ae[2]) * 8.6159e-4
                              + Sin(ae[3]) * 7.15e-5
                              + Sin(ae[4]) * 5.559e-5
                              - Sin(-an[1] + an[2] * 2.0) * 8.46e-5
                              + Sin(an[1] * -2.0 + an[2] * 3.0) * 9.181e-5
                              + Sin(-an[1] + an[3] * 2.0) * 2.003e-5
                              + Sin(an[1]) * 8.977e-5;
            elem[1 * 6 + 4] = Cos(ai[0]) * -1.2175e-4
                              + Cos(ai[1]) * 3.5825e-4
                              + Cos(ai[2]) * 2.9008e-4
                              + Cos(ai[3]) * 9.778e-5
                              + Cos(ai[4]) * 3.397e-5;
            elem[1 * 6 + 5] = Sin(ai[0]) * -1.2175e-4
                              + Sin(ai[1]) * 3.5825e-4
                              + Sin(ai[2]) * 2.9008e-4
                              + Sin(ai[3]) * 9.778e-5
                              + Sin(ai[4]) * 3.397e-5;
            elem[2 * 6 + 0] = 1.5159549
                              + Cos(an[2] - an[3] * 2.0 + ae[2]) * 9.74e-6
                              - Cos(an[1] - an[2]) * 1.06e-4
                              + Cos(an[1] * 2.0 - an[2] * 2.0) * 5.416e-5
                              - Cos(an[2] - an[3]) * 2.359e-5
                              - Cos(an[2] * 2.0 - an[3] * 2.0) * 7.07e-5
                              - Cos(an[2] * 3.0 - an[3] * 3.0) * 3.628e-5;
            elem[2 * 6 + 1] =
                Sin(an[0] - an[1] * 3.0 + an[2] * 2.0) * 6.6057e-4
                - Sin(an[0] * 2.0 - an[1] * 6.0 + an[2] * 4.0) * 7.651e-5
                - Sin(an[0] * 3.0 - an[1] * 9.0 + an[2] * 6.0) * 8.96e-6
                - Sin(an[0] * 4.0 - an[1] * 12.0 + an[2] * 8.0) * 2.53e-6
                - Sin(an[2] - an[3] * 4.0 + an[4] * 3.0) * 5.291e-5
                - Sin(an[2] - an[3] * 2.0 + ae[4]) * 7.34e-6
                - Sin(an[2] - an[3] * 2.0 + ae[3]) * 1.83e-6
                + Sin(an[2] - an[3] * 2.0 + ae[2]) * 1.4791e-4
                + Sin(an[2] - an[3] * 2.0 + ae[1]) * -7.77e-6
                + Sin(an[1] - an[2]) * 9.776e-5
                + Sin(an[1] * 2.0 - an[2] * 2.0) * 7.313e-5
                + Sin(an[1] * 3.0 - an[2] * 3.0) * 3.471e-5
                + Sin(an[1] * 4.0 - an[2] * 4.0) * 1.889e-5
                - Sin(an[2] - an[3]) * 6.789e-5
                - Sin(an[2] * 2.0 - an[3] * 2.0) * 8.286e-5
                + Sin(an[2] * 3.0 - an[3] * 3.0) * -3.381e-5
                - Sin(an[2] * 4.0 - an[3] * 4.0) * 1.579e-5
                - Sin(an[2] - an[4]) * 1.021e-5
                - Sin(an[2] * 2.0 - an[4] * 2.0) * 1.708e-5
                + t * 1.51614811 + 2.28540169;
            elem[2 * 6 + 2] = Cos(ae[0]) * -2.1e-7
                              - Cos(ae[1]) * 2.2795e-4
                              + Cos(ae[2]) * .00390469
                              + Cos(ae[3]) * 3.0917e-4
                              + Cos(ae[4]) * 2.2192e-4
                              + Cos(an[1]) * 2.934e-5
                              + Cos(an[2]) * 2.62e-5
                              + Cos(-an[1] + an[2] * 2.0) * 5.119e-5
                              - Cos(an[1] * -2.0 + an[2] * 3.0) * 1.0386e-4
                              - Cos(an[1] * -3.0 + an[2] * 4.0) * 2.716e-5
                              + Cos(an[3]) * -1.622e-5
                              + Cos(-an[2] + an[3] * 2.0) * 5.4923e-4
                              + Cos(an[2] * -2.0 + an[3] * 3.0) * 3.47e-5
                              + Cos(an[2] * -3.0 + an[3] * 4.0) * 1.281e-5
                              + Cos(-an[2] + an[4] * 2.0) * 2.181e-5
                              + Cos(an[2]) * 4.625e-5;
            elem[2 * 6 + 3] = Sin(ae[0]) * -2.1e-7
                              - Sin(ae[1]) * 2.2795e-4
                              + Sin(ae[2]) * .00390469
                              + Sin(ae[3]) * 3.0917e-4
                              + Sin(ae[4]) * 2.2192e-4
                              + Sin(an[1]) * 2.934e-5
                              + Sin(an[2]) * 2.62e-5
                              + Sin(-an[1] + an[2] * 2.0) * 5.119e-5
                              - Sin(an[1] * -2.0 + an[2] * 3.0) * 1.0386e-4
                              - Sin(an[1] * -3.0 + an[2] * 4.0) * 2.716e-5
                              + Sin(an[3]) * -1.622e-5
                              + Sin(-an[2] + an[3] * 2.0) * 5.4923e-4
                              + Sin(an[2] * -2.0 + an[3] * 3.0) * 3.47e-5
                              + Sin(an[2] * -3.0 + an[3] * 4.0) * 1.281e-5
                              + Sin(-an[2] + an[4] * 2.0) * 2.181e-5
                              + Sin(an[2]) * 4.625e-5;
            elem[2 * 6 + 4] = Cos(ai[0]) * -1.086e-5
                              - Cos(ai[1]) * 8.151e-5
                              + Cos(ai[2]) * .00111336
                              + Cos(ai[3]) * 3.5014e-4
                              + Cos(ai[4]) * 1.065e-4;
            elem[2 * 6 + 5] = Sin(ai[0]) * -1.086e-5
                              - Sin(ai[1]) * 8.151e-5
                              + Sin(ai[2]) * .00111336
                              + Sin(ai[3]) * 3.5014e-4
                              + Sin(ai[4]) * 1.065e-4;
            elem[3 * 6 + 0] = .72166316
                              - Cos(an[2] - an[3] * 2.0 + ae[2]) * 2.64e-6
                              - Cos(an[3] * 2.0 - an[4] * 3.0 + ae[4]) * 2.16e-6
                              + Cos(an[3] * 2.0 - an[4] * 3.0 + ae[3]) * 6.45e-6
                              - Cos(an[3] * 2.0 - an[4] * 3.0 + ae[2]) * 1.11e-6
                              + Cos(an[1] - an[3]) * -6.223e-5
                              - Cos(an[2] - an[3]) * 5.613e-5
                              - Cos(an[3] - an[4]) * 3.994e-5
                              - Cos(an[3] * 2.0 - an[4] * 2.0) * 9.185e-5
                              - Cos(an[3] * 3.0 - an[4] * 3.0) * 5.831e-5
                              - Cos(an[3] * 4.0 - an[4] * 4.0) * 3.86e-5
                              - Cos(an[3] * 5.0 - an[4] * 5.0) * 2.618e-5
                              - Cos(an[3] * 6.0 - an[4] * 6.0) * 1.806e-5;
            elem[3 * 6 + 1] =
                Sin(an[2] - an[3] * 4.0 + an[4] * 3.0) * 2.061e-5
                - Sin(an[2] - an[3] * 2.0 + ae[4]) * 2.07e-6
                - Sin(an[2] - an[3] * 2.0 + ae[3]) * 2.88e-6
                - Sin(an[2] - an[3] * 2.0 + ae[2]) * 4.079e-5
                + Sin(an[2] - an[3] * 2.0 + ae[1]) * 2.11e-6
                - Sin(an[3] * 2.0 - an[4] * 3.0 + ae[4]) * 5.183e-5
                + Sin(an[3] * 2.0 - an[4] * 3.0 + ae[3]) * 1.5987e-4
                + Sin(an[3] * 2.0 - an[4] * 3.0 + ae[2]) * -3.505e-5
                - Sin(an[3] * 3.0 - an[4] * 4.0 + ae[4]) * 1.56e-6
                + Sin(an[1] - an[3]) * 4.054e-5
                + Sin(an[2] - an[3]) * 4.617e-5
                - Sin(an[3] - an[4]) * 3.1776e-4
                - Sin(an[3] * 2.0 - an[4] * 2.0) * 3.0559e-4
                - Sin(an[3] * 3.0 - an[4] * 3.0) * 1.4836e-4
                - Sin(an[3] * 4.0 - an[4] * 4.0) * 8.292e-5
                + Sin(an[3] * 5.0 - an[4] * 5.0) * -4.998e-5
                - Sin(an[3] * 6.0 - an[4] * 6.0) * 3.156e-5
                - Sin(an[3] * 7.0 - an[4] * 7.0) * 2.056e-5
                - Sin(an[3] * 8.0 - an[4] * 8.0) * 1.369e-5
                + t * .72171851 + .85635879;
            elem[3 * 6 + 2] = Cos(ae[0]) * -2e-8
                              - Cos(ae[1]) * 1.29e-6
                              - Cos(ae[2]) * 3.2451e-4
                              + Cos(ae[3]) * 9.3281e-4
                              + Cos(ae[4]) * .00112089
                              + Cos(an[1]) * 3.386e-5
                              + Cos(an[3]) * 1.746e-5
                              + Cos(-an[1] + an[3] * 2.0) * 1.658e-5
                              + Cos(an[2]) * 2.889e-5
                              - Cos(-an[2] + an[3] * 2.0) * 3.586e-5
                              + Cos(an[3]) * -1.786e-5
                              - Cos(an[4]) * 3.21e-5
                              - Cos(-an[3] + an[4] * 2.0) * 1.7783e-4
                              + Cos(an[3] * -2.0 + an[4] * 3.0) * 7.9343e-4
                              + Cos(an[3] * -3.0 + an[4] * 4.0) * 9.948e-5
                              + Cos(an[3] * -4.0 + an[4] * 5.0) * 4.483e-5
                              + Cos(an[3] * -5.0 + an[4] * 6.0) * 2.513e-5
                              + Cos(an[3] * -6.0 + an[4] * 7.0) * 1.543e-5;
            elem[3 * 6 + 3] = Sin(ae[0]) * -2e-8
                              - Sin(ae[1]) * 1.29e-6
                              - Sin(ae[2]) * 3.2451e-4
                              + Sin(ae[3]) * 9.3281e-4
                              + Sin(ae[4]) * .00112089
                              + Sin(an[1]) * 3.386e-5
                              + Sin(an[3]) * 1.746e-5
                              + Sin(-an[1] + an[3] * 2.0) * 1.658e-5
                              + Sin(an[2]) * 2.889e-5
                              - Sin(-an[2] + an[3] * 2.0) * 3.586e-5
                              + Sin(an[3]) * -1.786e-5
                              - Sin(an[4]) * 3.21e-5
                              - Sin(-an[3] + an[4] * 2.0) * 1.7783e-4
                              + Sin(an[3] * -2.0 + an[4] * 3.0) * 7.9343e-4
                              + Sin(an[3] * -3.0 + an[4] * 4.0) * 9.948e-5
                              + Sin(an[3] * -4.0 + an[4] * 5.0) * 4.483e-5
                              + Sin(an[3] * -5.0 + an[4] * 6.0) * 2.513e-5
                              + Sin(an[3] * -6.0 + an[4] * 7.0) * 1.543e-5;
            elem[3 * 6 + 4] = Cos(ai[0]) * -1.43e-6
                              - Cos(ai[1]) * 1.06e-6
                              - Cos(ai[2]) * 1.4013e-4
                              + Cos(ai[3]) * 6.8572e-4
                              + Cos(ai[4]) * 3.7832e-4;
            elem[3 * 6 + 5] = Sin(ai[0]) * -1.43e-6
                              - Sin(ai[1]) * 1.06e-6
                              - Sin(ai[2]) * 1.4013e-4
                              + Sin(ai[3]) * 6.8572e-4
                              + Sin(ai[4]) * 3.7832e-4;
            elem[4 * 6 + 0] = .46658054
                              + Cos(an[3] * 2.0 - an[4] * 3.0 + ae[4]) * 2.08e-6
                              - Cos(an[3] * 2.0 - an[4] * 3.0 + ae[3]) * 6.22e-6
                              + Cos(an[3] * 2.0 - an[4] * 3.0 + ae[2]) * 1.07e-6
                              - Cos(an[1] - an[4]) * 4.31e-5
                              + Cos(an[2] - an[4]) * -3.894e-5
                              - Cos(an[3] - an[4]) * 8.011e-5
                              + Cos(an[3] * 2.0 - an[4] * 2.0) * 5.906e-5
                              + Cos(an[3] * 3.0 - an[4] * 3.0) * 3.749e-5
                              + Cos(an[3] * 4.0 - an[4] * 4.0) * 2.482e-5
                              + Cos(an[3] * 5.0 - an[4] * 5.0) * 1.684e-5;
            elem[4 * 6 + 1] =
                -Sin(an[2] - an[3] * 4.0 + an[4] * 3.0) * 7.82e-6
                + Sin(an[3] * 2.0 - an[4] * 3.0 + ae[4]) * 5.129e-5
                - Sin(an[3] * 2.0 - an[4] * 3.0 + ae[3]) * 1.5824e-4
                + Sin(an[3] * 2.0 - an[4] * 3.0 + ae[2]) * 3.451e-5
                + Sin(an[1] - an[4]) * 4.751e-5
                + Sin(an[2] - an[4]) * 3.896e-5
                + Sin(an[3] - an[4]) * 3.5973e-4
                + Sin(an[3] * 2.0 - an[4] * 2.0) * 2.8278e-4
                + Sin(an[3] * 3.0 - an[4] * 3.0) * 1.386e-4
                + Sin(an[3] * 4.0 - an[4] * 4.0) * 7.803e-5
                + Sin(an[3] * 5.0 - an[4] * 5.0) * 4.729e-5
                + Sin(an[3] * 6.0 - an[4] * 6.0) * 3e-5
                + Sin(an[3] * 7.0 - an[4] * 7.0) * 1.962e-5
                + Sin(an[3] * 8.0 - an[4] * 8.0) * 1.311e-5
                + t * .46669212 - .9155918;
            elem[4 * 6 + 2] = Cos(ae[1]) * -3.5e-7
                              + Cos(ae[2]) * 7.453e-5
                              - Cos(ae[3]) * 7.5868e-4
                              + Cos(ae[4]) * .00139734
                              + Cos(an[1]) * 3.9e-5
                              + Cos(-an[1] + an[4] * 2.0) * 1.766e-5
                              + Cos(an[2]) * 3.242e-5
                              + Cos(an[3]) * 7.975e-5
                              + Cos(an[4]) * 7.566e-5
                              + Cos(-an[3] + an[4] * 2.0) * 1.3404e-4
                              - Cos(an[3] * -2.0 + an[4] * 3.0) * 9.8726e-4
                              - Cos(an[3] * -3.0 + an[4] * 4.0) * 1.2609e-4
                              - Cos(an[3] * -4.0 + an[4] * 5.0) * 5.742e-5
                              - Cos(an[3] * -5.0 + an[4] * 6.0) * 3.241e-5
                              - Cos(an[3] * -6.0 + an[4] * 7.0) * 1.999e-5
                              - Cos(an[3] * -7.0 + an[4] * 8.0) * 1.294e-5;
            elem[4 * 6 + 3] = Sin(ae[1]) * -3.5e-7
                              + Sin(ae[2]) * 7.453e-5
                              - Sin(ae[3]) * 7.5868e-4
                              + Sin(ae[4]) * .00139734
                              + Sin(an[1]) * 3.9e-5
                              + Sin(-an[1] + an[4] * 2.0) * 1.766e-5
                              + Sin(an[2]) * 3.242e-5
                              + Sin(an[3]) * 7.975e-5
                              + Sin(an[4]) * 7.566e-5
                              + Sin(-an[3] + an[4] * 2.0) * 1.3404e-4
                              - Sin(an[3] * -2.0 + an[4] * 3.0) * 9.8726e-4
                              - Sin(an[3] * -3.0 + an[4] * 4.0) * 1.2609e-4
                              - Sin(an[3] * -4.0 + an[4] * 5.0) * 5.742e-5
                              - Sin(an[3] * -5.0 + an[4] * 6.0) * 3.241e-5
                              - Sin(an[3] * -6.0 + an[4] * 7.0) * 1.999e-5
                              - Sin(an[3] * -7.0 + an[4] * 8.0) * 1.294e-5;
            elem[4 * 6 + 4] = Cos(ai[0]) * -4.4e-7
                              - Cos(ai[1]) * 3.1e-7
                              + Cos(ai[2]) * 3.689e-5
                              - Cos(ai[3]) * 5.9633e-4
                              + Cos(ai[4]) * 4.5169e-4;
            elem[4 * 6 + 5] = Sin(ai[0]) * -4.4e-7
                              - Sin(ai[1]) * 3.1e-7
                              + Sin(ai[2]) * 3.689e-5
                              - Sin(ai[3]) * 5.9633e-4
                              + Sin(ai[4]) * 4.5169e-4;

            // Get rectangular (Uranus-reffered) coordinates of moons
            CrdsRectangular[] gust86Rect = new CrdsRectangular[MOONS_COUNT];

            for (int body = 0; body < MOONS_COUNT; body++)
            {
                double[] elem_body = new double[6];
                for (int i = 0; i < 6; i++)
                {
                    elem_body[i] = elem[body * 6 + i];
                }

                double[] x = new double[3];
                EllipticToRectangularN(gust86_rmu[body], elem_body, ref x);

                gust86Rect[body]   = new CrdsRectangular();
                gust86Rect[body].X = GUST86toVsop87[0] * x[0] + GUST86toVsop87[1] * x[1] + GUST86toVsop87[2] * x[2];
                gust86Rect[body].Y = GUST86toVsop87[3] * x[0] + GUST86toVsop87[4] * x[1] + GUST86toVsop87[5] * x[2];
                gust86Rect[body].Z = GUST86toVsop87[6] * x[0] + GUST86toVsop87[7] * x[1] + GUST86toVsop87[8] * x[2];
            }

            for (int i = 0; i < MOONS_COUNT; i++)
            {
                moons[i] = new CrdsRectangular(
                    rectUranus.X + gust86Rect[i].X,
                    rectUranus.Y + gust86Rect[i].Y,
                    rectUranus.Z + gust86Rect[i].Z
                    );
            }

            return(moons);
        }