//Static methods
//Tangible Process Only End


    ////////////////////////////////// Implementation /////////////////////////////

    public static CAABinaryStarDetails Calculate(double t, double P, double T, double e, double a, double i, double omega, double w)
    {
        double n = 360 / P;
        double M = CT.M360(n * (t - T));
        double E = CAAKepler.Calculate(M, e);

        E     = CT.D2R(E);
        i     = CT.D2R(i);
        w     = CT.D2R(w);
        omega = CT.D2R(omega);

        CAABinaryStarDetails details = new CAABinaryStarDetails();

        details.r = a * (1 - e * Math.Cos(E));

        double v = Math.Atan(Math.Sqrt((1 + e) / (1 - e)) * Math.Tan(E / 2)) * 2;

        details.Theta = Math.Atan2(Math.Sin(v + w) * Math.Cos(i), Math.Cos(v + w)) + omega;
        details.Theta = CT.M360(CT.R2D(details.Theta));

        double sinvw = Math.Sin(v + w);
        double cosvw = Math.Cos(v + w);
        double cosi  = Math.Cos(i);

        details.Rho = details.r * Math.Sqrt((sinvw * sinvw * cosi * cosi) + (cosvw * cosvw));

        return(details);
    }
Example #2
0
    public static double PassageThroNode(double k)
    {
        //convert from K to T
        double T        = k / 1342.23;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;
        double T4       = Tcubed * T;

        double D     = CT.M360(183.6380 + 331.73735682 * k + 0.0014852 * Tsquared + 0.00000209 * Tcubed - 0.000000010 * T4);
        double M     = CT.M360(17.4006 + 26.82037250 * k + 0.0001186 * Tsquared + 0.00000006 * Tcubed);
        double Mdash = CT.M360(38.3776 + 355.52747313 * k + 0.0123499 * Tsquared + 0.000014627 * Tcubed - 0.000000069 * T4);
        double omega = CT.M360(123.9767 - 1.44098956 * k + 0.0020608 * Tsquared + 0.00000214 * Tcubed - 0.000000016 * T4);
        double V     = CT.M360(299.75 + 132.85 * T - 0.009173 * Tsquared);
        double P     = CT.M360(omega + 272.75 - 2.3 * T);
        double E     = 1 - 0.002516 * T - 0.0000074 * Tsquared;

        //convert to radians
        D = CT.D2R(D);
        double D2 = 2 * D;
        double D4 = D2 * D2;

        M     = CT.D2R(M);
        Mdash = CT.D2R(Mdash);
        double Mdash2 = 2 * Mdash;

        omega = CT.D2R(omega);
        V     = CT.D2R(V);
        P     = CT.D2R(P);

        double JD = 2451565.1619 + 27.212220817 * k + 0.0002762 * Tsquared + 0.000000021 * Tcubed - 0.000000000088 * T4 - 0.4721 * Math.Sin(Mdash) - 0.1649 * Math.Sin(D2) - 0.0868 * Math.Sin(D2 - Mdash) + 0.0084 * Math.Sin(D2 + Mdash) - E * 0.0083 * Math.Sin(D2 - M) - E * 0.0039 * Math.Sin(D2 - M - Mdash) + 0.0034 * Math.Sin(Mdash2) - 0.0031 * Math.Sin(D2 - Mdash2) + E * 0.0030 * Math.Sin(D2 + M) + E * 0.0028 * Math.Sin(M - Mdash) + E * 0.0026 * Math.Sin(M) + 0.0025 * Math.Sin(D4) + 0.0024 * Math.Sin(D) + E * 0.0022 * Math.Sin(M + Mdash) + 0.0017 * Math.Sin(omega) + 0.0014 * Math.Sin(D4 - Mdash) + E * 0.0005 * Math.Sin(D2 + M - Mdash) + E * 0.0004 * Math.Sin(D2 - M + Mdash) - E * 0.0003 * Math.Sin(D2 - M * M) + E * 0.0003 * Math.Sin(D4 - M) + 0.0003 * Math.Sin(V) + 0.0003 * Math.Sin(P);

        return(JD);
    }
Example #3
0
//Static methods

    /////////////////////////////// Implementation ////////////////////////////////

    public static double EclipticLongitude(double JD)
    {
        double rho        = (JD - 2451545) / 365250;
        double rhosquared = rho * rho;
        double rhocubed   = rhosquared * rho;
        double rho4       = rhocubed * rho;

        //Calculate L0
        int    nL0Coefficients = GFX.g_L0UranusCoefficients.Length;
        double L0 = 0;
        int    i;

        for (i = 0; i < nL0Coefficients; i++)
        {
            L0 += GFX.g_L0UranusCoefficients[i].A * Math.Cos(GFX.g_L0UranusCoefficients[i].B + GFX.g_L0UranusCoefficients[i].C * rho);
        }

        //Calculate L1
        int    nL1Coefficients = GFX.g_L1UranusCoefficients.Length;
        double L1 = 0;

        for (i = 0; i < nL1Coefficients; i++)
        {
            L1 += GFX.g_L1UranusCoefficients[i].A * Math.Cos(GFX.g_L1UranusCoefficients[i].B + GFX.g_L1UranusCoefficients[i].C * rho);
        }

        //Calculate L2
        int    nL2Coefficients = GFX.g_L2UranusCoefficients.Length;
        double L2 = 0;

        for (i = 0; i < nL2Coefficients; i++)
        {
            L2 += GFX.g_L2UranusCoefficients[i].A * Math.Cos(GFX.g_L2UranusCoefficients[i].B + GFX.g_L2UranusCoefficients[i].C * rho);
        }

        //Calculate L3
        int    nL3Coefficients = GFX.g_L3UranusCoefficients.Length;
        double L3 = 0;

        for (i = 0; i < nL3Coefficients; i++)
        {
            L3 += GFX.g_L3UranusCoefficients[i].A * Math.Cos(GFX.g_L3UranusCoefficients[i].B + GFX.g_L3UranusCoefficients[i].C * rho);
        }

        //Calculate L4
        int    nL4Coefficients = GFX.g_L4UranusCoefficients.Length;
        double L4 = 0;

        for (i = 0; i < nL4Coefficients; i++)
        {
            L4 += GFX.g_L4UranusCoefficients[i].A * Math.Cos(GFX.g_L4UranusCoefficients[i].B + GFX.g_L4UranusCoefficients[i].C * rho);
        }


        double @value = (L0 + L1 * rho + L2 * rhosquared + L3 * rhocubed + L4 * rho4) / 100000000;

        //convert results back to degrees
        @value = CT.M360(CT.R2D(@value));
        return(@value);
    }
    public static double ApogeeParallax(double k)
    {
        //convert from K to T
        double T        = k / 1325.55;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;
        double T4       = Tcubed * T;

        double D = CT.M360(171.9179 + 335.9106046 * k - 0.0100383 * Tsquared - 0.00001156 * Tcubed + 0.000000055 * T4);

        D = CT.D2R(D);
        double M = CT.M360(347.3477 + 27.1577721 * k - 0.0008130 * Tsquared - 0.0000010 * Tcubed);

        M = CT.D2R(M);
        double F = CT.M360(316.6109 + 364.5287911 * k - 0.0125053 * Tsquared - 0.0000148 * Tcubed);

        F = CT.D2R(F);

        int    nApogeeCoefficients = GFX.g_MoonPerigeeApogeeCoefficients4.Length;
        double Parallax            = 3245.251;

        for (int i = 0; i < nApogeeCoefficients; i++)
        {
            Parallax += (GFX.g_MoonPerigeeApogeeCoefficients4[i].C + T * GFX.g_MoonPerigeeApogeeCoefficients4[i].T) * Math.Cos(D * GFX.g_MoonPerigeeApogeeCoefficients4[i].D + M * GFX.g_MoonPerigeeApogeeCoefficients4[i].M + F * GFX.g_MoonPerigeeApogeeCoefficients4[i].F);
        }

        return(Parallax / 3600);
    }
    public static double NeptuneInclinationJ2000(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;

        return(CT.M360(1.769953 + 0.0002256 * T + 0.00000023 * Tsquared));
    }
    public static double NeptuneLongitudePerihelionJ2000(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;

        return(CT.M360(48.120276 + 0.0291866 * T + 0.00007610 * Tsquared));
    }
    public static CAAEclipticalElementDetails FK4B1950ToFK5J2000(double i0, double w0, double omega0)
    {
        //convert to radians
        double L         = CT.D2R(5.19856209);
        double J         = CT.D2R(0.00651966);
        double i0rad     = CT.D2R(i0);
        double omega0rad = CT.D2R(omega0);
        double sini0rad  = Math.Sin(i0rad);
        double cosi0rad  = Math.Cos(i0rad);

        //Calculate some values used later
        double cosJ = Math.Cos(J);
        double sinJ = Math.Sin(J);
        double W    = L + omega0rad;
        double cosW = Math.Cos(W);
        double sinW = Math.Sin(W);
        double A    = sinJ * sinW;
        double B    = sini0rad * cosJ + cosi0rad * sinJ * cosW;

        //Calculate the values
        CAAEclipticalElementDetails details = new CAAEclipticalElementDetails();

        details.i = CT.R2D(Math.Asin(Math.Sqrt(A * A + B * B)));
        double cosi = cosi0rad * cosJ - sini0rad * sinJ * cosW;

        if (cosi < 0)
        {
            details.i = 180 - details.i;
        }

        details.w     = CT.M360(w0 + CT.R2D(Math.Atan2(A, B)));
        details.omega = CT.M360(CT.R2D(Math.Atan2(sini0rad * sinW, cosi0rad * sinJ + sini0rad * cosJ * cosW)) - 4.50001688);

        return(details);
    }
Example #8
0
//Static methods

    ///////////////////////// Implementation //////////////////////////////////////

    public static double Calculate(double JD)
    {
        double rho        = (JD - 2451545) / 365250;
        double rhosquared = rho * rho;
        double rhocubed   = rhosquared * rho;
        double rho4       = rhocubed * rho;
        double rho5       = rho4 * rho;

        //Calculate the Suns mean longitude
        double L0 = CT.M360(280.4664567 + 360007.6982779 * rho + 0.03032028 * rhosquared + rhocubed / 49931 - rho4 / 15300 - rho5 / 2000000);

        //Calculate the Suns apparent right ascension
        double SunLong    = CAASun.ApparentEclipticLongitude(JD);
        double SunLat     = CAASun.ApparentEclipticLatitude(JD);
        double epsilon    = CAANutation.TrueObliquityOfEcliptic(JD);
        COR    Equatorial = CT.Ec2Eq(SunLong, SunLat, epsilon);

        epsilon = CT.D2R(epsilon);
        double E = L0 - 0.0057183 - Equatorial.X * 15 + CT.DMS2D(0, 0, CAANutation.NutationInLongitude(JD)) * Math.Cos(epsilon);

        if (E > 180)
        {
            E = -(360 - E);
        }
        E *= 4; //Convert to minutes of time

        return(E);
    }
    public static double TrueLongitudeAscendingNode(double JD)
    {
        double TrueAscendingNode = MeanLongitudeAscendingNode(JD);

        double D = MeanElongation(JD);

        D = CT.D2R(D);
        double M = CAAEarth.SunMeanAnomaly(JD);

        M = CT.D2R(M);
        double Mdash = MeanAnomaly(JD);

        Mdash = CT.D2R(Mdash);
        double F = ArgumentOfLatitude(JD);

        F = CT.D2R(F);

        //Add the principal additive terms
        TrueAscendingNode -= 1.4979 * Math.Sin(2 * (D - F));
        TrueAscendingNode -= 0.1500 * Math.Sin(M);
        TrueAscendingNode -= 0.1226 * Math.Sin(2 * D);
        TrueAscendingNode += 0.1176 * Math.Sin(2 * F);
        TrueAscendingNode -= 0.0801 * Math.Sin(2 * (Mdash - F));

        return(CT.M360(TrueAscendingNode));
    }
    public static double TrueApogee(double k)
    {
        double MeanJD = MeanApogee(k);

        //convert from K to T
        double T        = k / 1325.55;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;
        double T4       = Tcubed * T;

        double D = CT.M360(171.9179 + 335.9106046 * k - 0.0100383 * Tsquared - 0.00001156 * Tcubed + 0.000000055 * T4);

        D = CT.D2R(D);
        double M = CT.M360(347.3477 + 27.1577721 * k - 0.0008130 * Tsquared - 0.0000010 * Tcubed);

        M = CT.D2R(M);
        double F = CT.M360(316.6109 + 364.5287911 * k - 0.0125053 * Tsquared - 0.0000148 * Tcubed);

        F = CT.D2R(F);

        int    nApogeeCoefficients = GFX.g_MoonPerigeeApogeeCoefficients2.Length;
        double Sigma = 0;

        for (int i = 0; i < nApogeeCoefficients; i++)
        {
            Sigma += (GFX.g_MoonPerigeeApogeeCoefficients2[i].C + T * GFX.g_MoonPerigeeApogeeCoefficients2[i].T) * Math.Sin(D * GFX.g_MoonPerigeeApogeeCoefficients2[i].D + M * GFX.g_MoonPerigeeApogeeCoefficients2[i].M + F * GFX.g_MoonPerigeeApogeeCoefficients2[i].F);
        }

        return(MeanJD + Sigma);
    }
    public static double EclipticLongitude(double JD)
    {
        double Ldash        = MeanLongitude(JD);
        double LdashDegrees = Ldash;

        Ldash = CT.D2R(Ldash);
        double D = MeanElongation(JD);

        D = CT.D2R(D);
        double M = CAAEarth.SunMeanAnomaly(JD);

        M = CT.D2R(M);
        double Mdash = MeanAnomaly(JD);

        Mdash = CT.D2R(Mdash);
        double F = ArgumentOfLatitude(JD);

        F = CT.D2R(F);

        double E = CAAEarth.Eccentricity(JD);
        double T = (JD - 2451545) / 36525;

        double A1 = CT.M360(119.75 + 131.849 * T);

        A1 = CT.D2R(A1);
        double A2 = CT.M360(53.09 + 479264.290 * T);

        A2 = CT.D2R(A2);
        double A3 = CT.M360(313.45 + 481266.484 * T);

        A3 = CT.D2R(A3);

        int nLCoefficients = GFX.g_MoonCoefficients1.Length;

        Debug.Assert(GFX.g_MoonCoefficients2.Length == nLCoefficients);
        double SigmaL = 0;

        for (int i = 0; i < nLCoefficients; i++)
        {
            double ThisSigma = GFX.g_MoonCoefficients2[i].A * Math.Sin(GFX.g_MoonCoefficients1[i].D * D + GFX.g_MoonCoefficients1[i].M * M + GFX.g_MoonCoefficients1[i].Mdash * Mdash + GFX.g_MoonCoefficients1[i].F * F);

            if (GFX.g_MoonCoefficients1[i].M != 0)
            {
                ThisSigma *= E;
            }

            SigmaL += ThisSigma;
        }

        //Finally the additive terms
        SigmaL += 3958 * Math.Sin(A1);
        SigmaL += 1962 * Math.Sin(Ldash - F);
        SigmaL += 318 * Math.Sin(A2);

        //And finally apply the nutation in longitude
        double NutationInLong = CAANutation.NutationInLongitude(JD);

        return(CT.M360(LdashDegrees + SigmaL / 1000000 + NutationInLong / 3600));
    }
    public static double JupiterLongitudeAscendingNodeJ2000(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;

        return(CT.M360(100.464407 + 0.1767232 * T + 0.00090700 * Tsquared - 0.000007272 * Tcubed));
    }
Example #13
0
    public static double PhaseAngle(double GeocentricElongation, double EarthObjectDistance, double EarthSunDistance)
    {
        //Convert from degrees to radians
        GeocentricElongation = CT.D2R(GeocentricElongation);

        //Return the result
        return(CT.M360(CT.R2D(Math.Atan2(EarthSunDistance * Math.Sin(GeocentricElongation), EarthObjectDistance - EarthSunDistance * Math.Cos(GeocentricElongation)))));
    }
    public static double VenusMeanLongitude(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;

        return(CT.M360(181.979801 + 58519.2130302 * T + 0.00031014 * Tsquared + 0.000000015 * Tcubed));
    }
    public static double JupiterLongitudePerihelionJ2000(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;

        return(CT.M360(14.331207 + 0.2155209 * T + 0.00072211 * Tsquared - 0.000004485 * Tcubed));
    }
    public static double SaturnMeanLongitudeJ2000(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;

        return(CT.M360(50.077444 + 1222.1138488 * T + 0.00021004 * Tsquared - 0.000000046 * Tcubed));
    }
    public static double MercuryLongitudePerihelion(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;

        return(CT.M360(77.456119 + 1.5564776 * T + 0.00029544 * Tsquared + 0.000000009 * Tcubed));
    }
    public static double SaturnInclinationJ2000(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;

        return(CT.M360(2.488879 + 0.0025514 * T - 0.00004906 * Tsquared + 0.000000017 * Tcubed));
    }
    public static double NeptuneLongitudeAscendingNodeJ2000(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;

        return(CT.M360(131.784057 - 0.0061651 * T - 0.00000219 * Tsquared - 0.000000078 * Tcubed));
    }
    public static double SunMeanAnomaly(double JD)
    {
        double T        = (JD - 2451545) / 36525;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;

        return(CT.M360(357.5291092 + 35999.0502909 * T - 0.0001536 * Tsquared + Tcubed / 24490000));
    }
    public static double JupiterInclinationJ2000(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;

        return(CT.M360(1.303267 - 0.0019877 * T + 0.00003320 * Tsquared + 0.000000097 * Tcubed));
    }
    public static double SaturnLongitudeAscendingNodeJ2000(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;

        return(CT.M360(113.665503 - 0.2566722 * T - 0.00018399 * Tsquared + 0.000000480 * Tcubed));
    }
    public static double UranusInclinationJ2000(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;

        return(CT.M360(0.773197 - 0.0016869 * T + 0.00000349 * Tsquared + 0.000000016 * Tcubed));
    }
    public static double MercuryLongitudeAscendingNode(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;

        return(CT.M360(48.330893 + 1.1861883 * T + 0.00017542 * Tsquared + 0.000000215 * Tcubed));
    }
    public static double UranusMeanLongitudeJ2000(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;

        return(CT.M360(314.055005 + 428.4669983 * T - 0.00000486 * Tsquared + 0.000000006 * Tcubed));
    }
    public static double SaturnLongitudePerihelionJ2000(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;

        return(CT.M360(93.057237 + 0.5665415 * T + 0.00052850 * Tsquared + 0.000004912 * Tcubed));
    }
    public static double UranusLongitudePerihelionJ2000(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;

        return(CT.M360(173.005291 + 0.0893212 * T - 0.00009470 * Tsquared + 0.000000414 * Tcubed));
    }
    public static double NeptuneMeanLongitudeJ2000(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;

        return(CT.M360(304.348665 + 218.4862002 * T + 0.00000059 * Tsquared - 0.000000002 * Tcubed));
    }
    public static double UranusLongitudeAscendingNodeJ2000(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;

        return(CT.M360(74.005957 + 0.0741431 * T + 0.00040539 * Tsquared + 0.000000119 * Tcubed));
    }
    public static double JupiterMeanLongitudeJ2000(double JD)
    {
        double T        = (JD - 2451545.0) / 36525;
        double Tsquared = T * T;
        double Tcubed   = Tsquared * T;

        return(CT.M360(34.351519 + 3034.9056606 * T - 0.00008501 * Tsquared + 0.000000016 * Tcubed));
    }