Skocz do zawartości

Algorytmy astronomiczne czyli Python w rachunkach astro. - Cz. IX Księżyc.

Wiesiek1952

Przez Wiesiek1952
w Oprogramowanie

 Udostępnij

Rekomendowane odpowiedzi

Wiesiek1952

Wiesiek1952

Opublikowano
Opublikowano

Księżyc nie jest nadzwyczaj kochany przez astrofotografów. W astronawigacji jest uważany za bardzo trudny i jest bardzo niepopularny. Linia pozycyjna "z Księżyca" jest mało dokładna, trudna w rachunkach bo wymaga uwzględnienia wielu poprawek innych bądź zupełnie nieobecnych w astronawigacji z gwiazd, słońca czy planet.

 

Poniższy kod w Pythonie wylicza efemerydy Księżyca z dokładnością wystarczającą do nawigacji czy obserwacji amatorskich. Pełne i dokładne wyliczenie wymaga uwzględnienia ogromnej ilości składowych. Naprawdę jest tego dużo.

 

W załącznikach jest też kompletny program wyliczający efemerydy księżyca z zastosowaniem procedur z poprzednich odcinków. 

 

Uruchomienie programu produkuje wyniki jak niżej:

image.png.b17e1bbbf9923364c19bd93910451ca6.png

 

  

#     //  ********************************************************************  //
#     //  *     Obliczanie efemeryd Ksiezyca wymaga uwzglednienia            *  //
#     //  *     kilkuset  składowych  harmonicznych  jego   ruchu            *  //
#     //  *                                                                  *  //
#     //  *     przyblizona dokładność efemeryd :                            *  //
#     //  *                      10   sekund kątowych w długości  ok. 0.2'   *  //
#     //  *                       3   sekund kątowych w deklinacji           *  //
#     //  *                       0.2 sekund kątowych w paralaksie           *  //
#     //  *                                                                  *  //
#     //  *    Do celów nawigacyjnych dokładności te sa wystarczające        *  //
#     //  ********************************************************************  //

# ******************************************************************************************

from PunktClass import *
from AstroProc import julian_day
from math import *
from MathOwn import *


def moon(current_day: day_in_calendar, current_time: present_time) -> moon_ephemeries:
    local_day = current_day
    local_time = current_time
    #        //*****************************************  zmiana czasu z UT na ET
    jd = julian_day(local_day)
    t = (jd - 2415020) / 36525
    dt = -0.41 + 1.2053 * t + 0.4992 * t * t
    local_minutes = local_time.minute + dt
    czas = (local_time.hour + local_minutes / 60 + local_time.seconds / 3600)
    local_day.day = local_day.day + czas / 24
    jd = julian_day(current_day)
    t = (jd - 2415020.0) / 36525.0

    #        //********************************************************************
    L1 = 270.434164 + 481267.8831 * t - 0.001133 * t * t \
         + 0.0000019 * t * t * t
    M = 358.475833 + 35999.0498 * t - 0.000150 * t * t \
        - 0.0000033 * t * t * t
    M1 = 296.104608 + 477198.8491 * t + 0.009192 * t * t \
         + 0.0000144 * t * t * t
    D = 350.737486 + 445267.1142 * t - 0.001436 * t * t \
        + 0.0000019 * t * t * t
    F = 11.250889 + 483202.0251 * t - 0.003211 * t * t \
        - 0.0000003 * t * t * t
    OM = 259.183275 - 1934.1420 * t + 0.002078 * t * t \
         + 0.0000022 * t * t * t
    while L1 > 360:
        L1 = L1 - 360
    while M > 360:
        M = M - 360
    while M1 > 360:
        M1 = M1 - 360
    while D > 360:
        D = D - 360
    while F > 360:
        F = F - 360
    while OM < 0:
        OM = OM + 360


    xx = sin((51.2 + 20.2 * t) * TO_RAD)
    t1 = 0.000233 * xx
    t2 = -0.001778 * xx
    t3 = 0.000817 * xx
    t4 = 0.002011 * xx
    t5 = 0.003964 * sin((346.560 + 132.870 * t - 0.0091731 * t * t) * TO_RAD)
    xx = sin(OM * TO_RAD)
    t6 = 0.001964 * xx
    t7 = 0.002541 * xx
    t8 = 0.001964 * xx
    t9 = -0.024691 * xx
    t10 = -0.0043288 * sin((OM + 275.05 - 2.30 * t) * TO_RAD)
    L1 = L1 + t1 + t5 + t6
    M = (M + t2) * TO_RAD
    M1 = (M1 + t3 + t5 + t7) * TO_RAD
    D = (D + t4 + t5 + t8) * TO_RAD
    F = (F + t5 + t9 + t10) * TO_RAD

    OM = OM * TO_RAD
    e_local = 1 - 0.002495 * t - 0.00000752 * t * t
    e2 = e_local * e_local
    lambda_value = L1

    ttt = [0, 6.288750 * sin(M1),
           1.274018 * sin(2 * D - M1), 0.658309 * sin(2 * D),
           0.213616 * sin(2 * M1), -0.185596 * sin(M) * e_local,
           -0.114336 * sin(2 * F), 0.058793 * sin(2 * D - 2 * M1),
           0.057212 * sin(2 * D - M - M1) * e_local, 0.053320 * sin(2 * D + M1),
           0.045874 * sin(2 * D - M) * e_local, 0.041024 * sin(M1 - M) * e_local,
           -0.034718 * sin(D), -0.030465 * sin(M + M1) * e_local,
           0.015326 * sin(2 * D - 2 * F), -0.012528 * sin(2 * F + M1),
           -0.010980 * sin(2 * F - M1), 0.010674 * sin(4 * D - M1),
           0.010034 * sin(3 * M1), 0.008548 * sin(4 * D - 2 * M1),
           -0.007910 * sin(M - M1 + 2 * D) * e_local, -0.006783 * sin(2 * D + M) * e_local,
           0.005162 * sin(M1 - D), 0.005000 * sin(M + D) * e_local,
           0.004049 * sin(M1 - M + 2 * D) * e_local, 0.003996 * sin(2 * M1 + 2 * D),
           0.003862 * sin(4 * D), 0.003665 * sin(2 * D - 3 * M1),
           0.002695 * sin(2 * M1 - M) * e_local, 0.002602 * sin(M1 - 2 * F - 2 * D),
           0.002396 * sin(2 * D - M - 2 * M1) * e_local, -0.002349 * sin(M1 + D),
           0.002249 * sin(2 * D - 2 * M) * e2, -0.002125 * sin(2 * M1 + M) * e_local,
           -0.002079 * sin(2 * M) * e2, 0.002059 * sin(2 * D - M1 - 2 * M) * e2,
           -0.001773 * sin(M1 + 2 * D - 2 * F), -0.001595 * sin(2 * F + 2 * D),
           0.001220 * sin(4 * D - M - M1) * e_local, -0.001110 * sin(2 * M1 + 2 * F),
           0.000892 * sin(M1 - 3 * D), -0.000811 * sin(M + M1 + 2 * D) * e_local,
           0.000761 * sin(4 * D - M - 2 * M1) * e_local, 0.000717 * sin(M1 - 2 * M) * e2,
           0.000704 * sin(M1 - 2 * M - 2 * D) * e2, 0.000693 * sin(M - 2 * M1 + 2 * D) * e_local,
           0.000598 * sin(2 * D - M - 2 * F) * e_local, 0.000550 * sin(M1 + 4 * D),
           0.000538 * sin(4 * M1), 0.000521 * sin(4 * D - M) * e_local,
           0.000486 * sin(2 * M1 - D)
           ]

    for k in range(51):
        lambda_value = lambda_value + ttt[k]

    B = 0
    ttt2 = [0, 5.128189 * sin(F),
            0.280606 * sin(M1 + F), 0.277693 * sin(M1 - F),
            0.173238 * sin(2 * D - F), 0.055413 * sin(2 * D + F - M1),
            0.046272 * sin(2 * D - F - M1), 0.032573 * sin(2 * D + F),
            0.017198 * sin(2 * M1 + F), 0.009267 * sin(2 * D + M1 - F),
            0.008823 * sin(2 * M1 - F), 0.008247 * sin(2 * D - M - F) * e_local,
            0.004323 * sin(2 * D - F - 2 * M1), 0.004200 * sin(2 * D + F + M1),
            0.003372 * sin(F - M - 2 * D) * e_local, 0.002472 * sin(2 * D + F - M - M1) * e_local,
            0.002222 * sin(2 * D + F - M) * e_local, 0.002072 * sin(2 * D - F - M - M1) * e_local,
            0.001877 * sin(F - M + M1) * e_local, 0.001828 * sin(4 * D - F - M1),
            -0.001803 * sin(F + M) * e_local, -0.001750 * sin(3 * F),
            0.001570 * sin(M1 - M - F) * e_local, -0.001487 * sin(F + D),
            -0.001481 * sin(F + M + M1) * e_local, 0.001417 * sin(F - M - M1) * e_local,
            0.001350 * sin(F - M) * e_local, 0.001330 * sin(F - D),
            0.001106 * sin(F + 3 * M1), 0.001020 * sin(4 * D - F),
            0.000833 * sin(F + 4 * D - M1), 0.000781 * sin(M1 - 3 * F),
            0.000670 * sin(F + 4 * D - 2 * M1), 0.000606 * sin(2 * D - 3 * F),
            0.000597 * sin(2 * D + 2 * M1 - F), 0.000492 * sin(2 * D + M1 - M - F) * e_local,
            0.000450 * sin(2 * M1 - F - 2 * D), 0.000439 * sin(3 * M1 - F),
            0.000423 * sin(F + 2 * D + 2 * M1), 0.000422 * sin(2 * D - F - 3 * M1),
            -0.000367 * sin(M + F + 2 * D - M1) * e_local, -0.000353 * sin(M + F + 2 * D) * e_local,
            0.000331 * sin(F + 4 * D), 0.000317 * sin(2 * D + F - M + M1) * e_local,
            0.000306 * sin(2 * D - 2 * M - F) * e2, -0.000283 * sin(M1 + 3 * F)
            ]

    for k in range(46):
        B = B + ttt2[k]

    w1 = 0.0004664 * cos(OM)
    w2 = 0.0000754 * cos(OM + (275.05 - 2.30 * t) * TO_RAD)
    beta = B * (1 - w1 - w2)
    paralaks = 0.950724 \
               + 0.051818 * cos(M1) \
               + 0.009531 * cos(2 * D - M1) \
               + 0.007843 * cos(2 * D) \
               + 0.002824 * cos(2 * M1) \
               + 0.000857 * cos(2 * D + M1) \
               + 0.000533 * cos(2 * D - M) * e_local \
               + 0.000401 * cos(2 * D - M - M1) * e_local \
               + 0.000320 * cos(M1 - M) * e_local \
               - 0.000271 * cos(D) \
               - 0.000264 * cos(M + M1) * e_local \
               - 0.000198 * cos(2 * F - M1) \
               + 0.000173 * cos(3 * M1) \
               + 0.000167 * cos(4 * D - M1) \
               - 0.000111 * cos(M) * e_local \
               + 0.000103 * cos(4 * D - 2 * M1) \
               - 0.000084 * cos(2 * M1 - 2 * D) \
               - 0.000083 * cos(2 * D + M) * e_local \
               + 0.000079 * cos(2 * D + 2 * M1) \
               + 0.000072 * cos(4 * D) \
               + 0.000064 * cos(2 * D - M + M1) * e_local \
               - 0.000063 * cos(2 * D + M - M1) * e_local \
               + 0.000041 * cos(M + D) * e_local \
               + 0.000035 * cos(2 * M1 - M) * e_local \
               - 0.000033 * cos(3 * M1 - 2 * D) \
               - 0.000030 * cos(M1 + D) \
               - 0.000029 * cos(2 * F - 2 * D) \
               - 0.000029 * cos(2 * M1 + M) * e_local \
               + 0.000026 * cos(2 * D - 2 * M) * e2 \
               - 0.000023 * cos(2 * F - 2 * D + M1) \
               + 0.000019 * cos(4 * D - M - M1) * e_local

    eps = (23.452294 - 0.0130125 * t - 0.00000164 * t * t + 0.000000503 * t * t * t) * TO_RAD
    lambda_value = lambda_value * TO_RAD
    beta = beta * TO_RAD

    licznik = sin(lambda_value) * cos(eps) - tan(beta) * sin(eps)
    mianownik = cos(lambda_value)
    rekM = atan(licznik / mianownik)
    if mianownik < 0:
        rekM = rekM + pi
    if rekM < 0:
        rekM = rekM + TWO_PI
    decM = asin(sin(beta) * cos(eps) + cos(beta) * sin(eps) * sin(lambda_value))
    sd = 0.272476 * paralaks * 60

    moon_data = moon_ephemeries(rekM, decM, paralaks * 60, sd)
    return moon_data

Moon_AP.zip

  • Lubię 1
Odnośnik do komentarza
Udostępnij na innych stronach

Dołącz do dyskusji

Możesz dodać zawartość już teraz a zarejestrować się później. Jeśli posiadasz już konto, zaloguj się aby dodać zawartość za jego pomocą.

Gość
Dodaj odpowiedź do tematu...

×   Wklejono zawartość z formatowaniem.   Usuń formatowanie

  Dozwolonych jest tylko 75 emoji.

×   Odnośnik został automatycznie osadzony.   Przywróć wyświetlanie jako odnośnik

×   Przywrócono poprzednią zawartość.   Wyczyść edytor

×   Nie możesz bezpośrednio wkleić grafiki. Dodaj lub załącz grafiki z adresu URL.

×
 Udostępnij
Tematy
×
×
  • Dodaj nową pozycję...

Powiadomienie o plikach cookie

Umieściliśmy na Twoim urządzeniu pliki cookie, aby pomóc Ci usprawnić przeglądanie strony. Możesz dostosować ustawienia plików cookie, w przeciwnym wypadku zakładamy, że wyrażasz na to zgodę.