Mondposition - Coding Challenge

h_c_greier · 26. Juli 2023

Freunde der rechnenden Astronomie,

ich bin auf der Suche nach einem möglichst effizienten Script, das die Mondposition berechnen soll.

Die Vorgaben:
Sprache: prizipiell egal, Scripte von Webseiten, aus der üblichen Literatur, selbst geschriebene, ...
Geozentrische ekliptikale Koordinaten [L, B, R]
Ausgabe L, B in Grad, R in km
Genauigkeit L,B <= 2' (reicht für Auf-/Untergangsrechnung später)
Genauigkeit R <= 1000 km =ca. 0.25% mittlere Mondentfernung (384400 km)

Natürlich alles diskutabel.

Ziel:
Die Algorithmen sollen so einfach wie möglich sein. Hilfsfunktionen können 'ausgelagert' oder verbaut sein.
Zunächst mal wird der Zeitrahmen 1900-2100 angepeilt.
Man könnte Performance-Tests machen.

Es sollen erstmal die geozentr. Ekliptikkoordinaten genügen, die Weiterrechnung zu RA/DEC usw. ist ja dann für alle gleich. Ich habe die Scripte "MiniMoon" aus "Astronomie mit dem Personal Computer", den Algorithmus von P. Schlyter sowie den von den "Grundlagen der Ephemeridenrechnung" bereits umgesetzt. Webseite dazu folgt noch.

Wer hat Zeit & Lust? Durchsucht mal eure Festplatten und präsentiert eure Scripte!

cs,
harald

--

Specht · 26. Juli 2023

Hallo Harald,

in meinem Planetariumprogramm verwende ich jetzt die verkürzte ELP 2000/82-Theorie von Meeus aus seinem Buch. Das Verhältnis der Anzahl von Termen zu Genauigkeit ist mM nach optimal, für mich der beste Weg. Hut ab vor dem Altmeister Jean Meeus...

Für die Auf- und Untergangsrechnung habe ich einen eigenen Algorithmus programmiert, der sogar global fehlerfrei funktioniert. Die Idee: Es wird für jeweils einen Tag eine große Anzahl von Mondhöhen als Funktion der Zeit berechnet und immer zwischen zwei (korrigierten) Mondhöhen linear nach Nullstellen gesucht. So gehen einem auch die Tage nicht durch die Lappen, an denen der Mond überhaupt nicht auf- oder untergeht. Interessant auch für höhere Breiten, und sehr genau.

particle_gun · 27. Juli 2023

Hallo,

Schöne Aufgabe für ChatGTP

Interessante Idee, im Moment hab ich leider keine Zeit aber werde mir das mal im Hinterkopf behalten und melde mich.

Diese Bibliothek könnte hilfreich sein:

Skyfield — documentation

Almanac Computation — Skyfield documentation

Grüße
Stefanie

astrowolf67 · 27. Juli 2023

Hallo Harald,

im Montenbruck ist ein C++ Code enthalten der auf 1" genau ist.
Für Auf- und Untergänge gibt es dort auch eine Implementation in C++ .

CS
Wolfgang

h_c_greier · 27. Juli 2023

Hi Volker,

ja Meeus geht immer, seine gekürzte Version hat aber immer noch 60 Terme in Länge/Radius sowie auch in Breite. Sicher, er sagt man bekommt 10" in Länge und 4" in Breite Genauigkeit, was für die meisten Zwecke - außer Bedeckungen und Finsternisse - ausreichend ist. Will ich hier gar nicht

Es geht mir hier mehr um "möglichst kurz und knapp und: simpel", wobei die Daten immer noch "genau genug" für eine A/U Rechnung sein sollen. Ich schätze da dürften 1'-2' reichen. Und da verliert Meeus z.B. gegen MiniMoon von Montenbruck/Pfleger (AmdPC) von der Performanz her um L.Ä.N.G.E.N

Zitat von Specht:
Für die Auf- und Untergangsrechnung habe ich einen eigenen Algorithmus programmiert

Würde dein eigenes A/U Script gerne mal kennen lernen

@ Stefanie

Zitat von particle_gun:
Schöne Aufgabe für ChatGTP

LOL, nein, sicher kein Thema für ChatGPT. Das ist für sowas Spezielles völlig - ich wiederhole: völlig - ungeeignet. Schon mal probiert? Der Bot labert dich zu mit "wo man Scripte findet" und gibt vielleicht ein paar Anregungen, für jemanden der sich schon länger damit beschäftigt ist das Spinat bla blubb. Und konkrete Beispiele, ui ui. Wenn man den Bot 124mal verbessern muss kann ich es gleich selber schreiben

Aber danke für den Link zu Skyfield! Kenne ich. Dort steht

"Its results should agree with the positions generated by the United States Naval Observatory and their Astronomical Almanac to within 0.0005 arcseconds".

Das suggeriert eine Ultragenauigkeit, es sagt aber nur, dass die Abweichungen zum Almanac so klein sind/sein sollen. Und die Scripten zum Mond im Almanac/+Supplement sind meines Wissens keine mas genau. Oder doch?
Schon möglich, aber wir wollen hier nicht mit Kanonen auf Spatzen schießen. Es geht auch um einen gewissen Lerneffekt. Irgendein Library installieren oder eine API abfragen kann jeder HinzKunz. Alles Astronomische sollte intern laufen. Die Devise sollte lauten "selber machen" mit ausreichend Genauigkeit (siehe oben). Meinetwegen die üblichen verdächtigen Scripte aus den Büchern, halt ein wenig optimert was die Performanz betrifft.

@ Wolfgang

im Montenbruck ist ein C++ Code enthalten der auf 1" genau ist.

ja, danke, ich kenne das Buch. Du meinst dort das Kapitel 8.2, dass sich auf die Brownsche Mondtheorie bezieht, und in Kapitel 8.4 wird für kleine Schrittweiten mit Tschebyscheff-Approximation gearbeitet. Das ist super und schön und gut, das geht hier aber am Ziel vorbei, siehe mein Eingangspost, ich brache hier keine 1" Genauigkeit.

cs,
harald

--

maximilian · 27. Juli 2023

Hallo!

Zitat von h_c_greier:
LOL, nein, sicher kein Thema für ChatGPT. Das ist für sowas Spezielles völlig - ich wiederhole: völlig - ungeeignet.

Ich glaube, Du unterschätzt ChatGPT

> Ich: Write a short program in BASIC to calculate the position of the moon
> ChatGTP: In BASIC, calculating the position of the moon involves complex astronomical calculations beyond the scope of a short program. However, I can provide you with a simple BASIC program that will give you the moon's phase (percentage illuminated) based on the date. Keep in mind that for accurate moon position calculations, more sophisticated algorithms and data sources are necessary.
Es folgt ein Programmlisting mit 29 Zeilen, das die Mondphase berechnet und ausgibt. Inklusive Ein- und Ausganbe.

Also eine weitere Iteration, „short“ weggelassen und BASIC durch python ersetzt:
> Ich: Write a program in python to calculate the position of the moon
> ChatGPT:

Code:

pip install skyfield

from skyfield.api import load, Topos

def calculate_moon_position(date_time):
    # Load the planetary ephemeris data
    planets = load('de421.bsp')
    earth, moon = planets['earth'], planets['moon']

    # Create a timescale
    ts = load.timescale()

    # Convert the input date_time to a Skyfield Time object
    time = ts.utc(date_time.year, date_time.month, date_time.day,
                  date_time.hour, date_time.minute, date_time.second)

    # Calculate the position of the moon relative to the Earth
    astrometric = (earth + Topos(latitude_degrees=0, longitude_degrees=0)).at(time).observe(moon)
    apparent = astrometric.apparent()

    # Get the right ascension and declination of the moon
    ra, dec, distance = apparent.radec()

    # Get the azimuth and altitude of the moon for a specific observer (latitude, longitude, elevation)
    observer_latitude_degrees = 0.0
    observer_longitude_degrees = 0.0
    observer_elevation_m = 0.0
    observer = earth + Topos(latitude_degrees=observer_latitude_degrees,
                             longitude_degrees=observer_longitude_degrees,
                             elevation_m=observer_elevation_m)
    apparent_observer = observer.at(time).observe(moon)
    azimuth, altitude, distance = apparent_observer.apparent().altaz()

    return ra.hours, dec.degrees, azimuth.degrees, altitude.degrees

if __name__ == "__main__":
    from datetime import datetime

    # Example usage:
    date_time = datetime(2023, 7, 26, 12, 0, 0)  # Replace with your desired date and time
    ra, dec, azimuth, altitude = calculate_moon_position(date_time)

    print(f"Moon Right Ascension: {ra:.2f} hours")
    print(f"Moon Declination: {dec:.2f} degrees")
    print(f"Moon Azimuth: {azimuth:.2f} degrees")
    print(f"Moon Altitude: {altitude:.2f} degrees")

Wenn man ein bisschen rumprobiert bekommt man das Ergebnis bestimmt auch in einer anderen Skriptsprache!

Viele Grüße
Maximilian

maximilian · 27. Juli 2023

Hallo, ich nochmal...

musste ChatGPT natürlich auch nach einem Programm/Skrpit in Lua fragen, z.B. für den Ti-Nspire Taschenrechner:

Code:

-- Load the nspire-epx library
local epx = require("epx")

-- Function to calculate the moon's position
function calculate_moon_position(year, month, day, hour, minute, second)
    local ts = epx.load_timescale()

    -- Convert the input date and time to a timescale object
    local time = ts:utc(year, month, day, hour, minute, second)

    -- Load the planetary ephemeris data
    local planets = epx.load('de421.bsp')
    local earth, moon = planets['earth'], planets['moon']

    -- Calculate the moon's position relative to the Earth
    local astrometric = (earth + epx.topos(0, 0, 0)):at(time):observe(moon)
    local apparent = astrometric:apparent()

    -- Get the right ascension and declination of the moon
    local ra, dec, distance = apparent:radec()

    -- Get the azimuth and altitude of the moon for a specific observer (latitude, longitude, elevation)
    local observer_latitude_degrees = 0.0
    local observer_longitude_degrees = 0.0
    local observer_elevation_m = 0.0
    local observer = earth + epx.topos(observer_latitude_degrees,
                                       observer_longitude_degrees,
                                       observer_elevation_m)
    local apparent_observer = observer:at(time):observe(moon)
    local azimuth, altitude, distance = apparent_observer:apparent():altaz()

    return ra:hours(), dec:degrees(), azimuth:degrees(), altitude:degrees()
end

-- Example usage
local year = 2023
local month = 7
local day = 26
local hour = 12
local minute = 0
local second = 0

local ra, dec, azimuth, altitude = calculate_moon_position(year, month, day, hour, minute, second)
print("Moon Right Ascension: " .. ra)
print("Moon Declination: " .. dec)
print("Moon Azimuth: " .. azimuth)
print("Moon Altitude: " .. altitude)

Eine kurze Erklärung wie die Berechung funktioniert gibt es auch dazu, ebenso wie die Quelle für die inkludierte „epx“ Bibliothek.

Grüße
Maximilian

stefanj9 · 27. Juli 2023

Zitat von maximilian:
[…]
Also eine weitere Iteration, „short“ weggelassen und BASIC durch python ersetzt:
> Ich: Write a program in python to calculate the position of the moon
> ChatGPT:

Code:

pip install skyfield from skyfield.api import load, Topos […] [/QUOTE] Cool, ich glaube, ich muss den Code mal testen :cool: CS & VG Stefan

h_c_greier · 27. Juli 2023

Hallo Maximilian,

Zitat von maximilian:
Ich glaube, Du unterschätzt ChatGPT

Keineswegs! Das kann total viel. Nur leider nicht das, was ich hier möchte

Zitat von maximilian:
local planets = epx.load('de421.bsp')

und

Ja und hier ist genau das "Problem", es werden externe Daten/Routinen verwendet. Sicher, kann man machen. Aber der Code hier sollte generisch sein, soll heißen alles wird in einer Funktion/Routine berechnet. Keine externen API-Abfragen oder laden von Bibliotheken woher auch immer oder sonst ein Gedöns. Back to square one, quasi.

Klar, Nebenfunktionen darf/soll man machen, keine Ahnung, sowas wie "INT(...)", das die Nachkommastellen abschneidet, oder die separate Berechnung des Julianischen Tages JD, etc.
Ich hätte das in den obigen Vorgaben vielleicht dazu schreiben sollen

Gib bei chatGPT mal ein: "Roger W. Sinnott BASIC code for the Moon"

Das kann es, es gibt einen (Pseudo-)Code zurück, mit dem man gaaaanz prinzipiell was anfangen könnte:

Code:

Function JulianDate(year, month, day)
    If month <= 2 Then
        year = year - 1
        month = month + 12
    End If

    A = Int(year / 100)
    B = 2 - A + Int(A / 4)

    JD = Int(365.25 * (year + 4716)) + Int(30.6001 * (month + 1)) + day + B - 1524.5

    Return JD
End Function

Function MoonPosition(JD)
    D = JD - 2451550.1
    T = D / 36525

    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
    M = ToRadians(M)
    E = 0.016706 - 0.00004204 * T - 0.0000001236 * T * T

    C = (1.914602 - 0.004817 * T - 0.000014 * T * T) * Sin(M) + (0.019993 - 0.000101 * T) * Sin(2 * M) + 0.000289 * Sin(3 * M)
    Theta = L1 + C

    Omega = 125.04452 - 1934.136261 * T + 0.0020708 * T * T + 0.00000215 * T * T * T

    Lambda = ToDegrees(Theta - 0.00569 - 0.00478 * Sin(ToRadians(Omega)))

    Beta = ToDegrees(Asin(Sin(ToRadians(Theta - Omega)) * Sin(ToRadians(24.1984))))

    Return (Lambda, Beta)
End Function

Function ToRadians(degrees)
    Return degrees * 0.0174533
End Function

Function ToDegrees(radians)
    Return radians * 57.2958
End Function

Perfekt ist das natürlich nicht. Wenn man dann nach "perturbation terms" fragt kommt dieselbe Geschichte nochmal, außer dass die Koordinaten dann über XYZ berechnet werden, keine perturbations whatsoever....
Und was tut z.B. die Variable "D"? Gar nichts, auf der faulen Haut liegen, es sei ihr gegönnt

Und es wird stillschweigend davon ausgegangen, dass die Funktion "INT(...)" existiert. Es gibt Routinen für ToRadians und ToDegrees an, INT fehlt. Aber das ist ja schonmal was. Außer, dass man den Namen Roger W. Sinnott schon mal gehört haben muss, um die Frage überhaupt so stellen zu können....

chatGPT ist kommt mir machmal vor wie die berühmte Allwissende Müllhalde

cs,
harald

--

maximilian · 27. Juli 2023

Hallo!

Jetzt hat er/sie/es mir eine kompakte Version in C ohne externe Binliotheken gemacht. Das müsste prima auf einem Arduino oder Raspberry Pi laufen (oder auch im Terminal eines jeden unix Rechners). Sieht auf den ersten Blick nicht schlecht aus. ChatGPT lernt auch immer dazu: Wenn man die Aufgabe mehrmals hintereinander stellt, evtl. mit kleinen Veränderungen, kommt jedesmal ein etwas anderes Ergebnis dabei heraus.

ich> please write a program in c to compute the position of the moon without using external libraries

ChatCPT> Computing the position of the moon is a complex task that involves various mathematical formulas and algorithms. Here's a simplified version of a C program that uses basic mathematical equations to estimate the position of the moon relative to the Earth. Note that this is a basic approximation and may not be as accurate as professional libraries or astronomical algorithms.

Code:

#include <stdio.h>
#include <math.h>

#define PI 3.14159265358979323846

// Function to calculate the position of the moon
void moonPosition(double jd, double *moonLatitude, double *moonLongitude) {
    double T, L0, l, M, C, lambda, beta;
   
    // Julian centuries since J2000.0
    T = (jd - 2451545.0) / 36525.0;

    // Mean longitude of the Moon
    L0 = fmod(218.316 + 481267.881 * T, 360.0);
   
    // Mean anomaly of the Moon
    M = fmod(134.963 + 477198.867 * T, 360.0);
   
    // Mean elongation of the Moon
    l = fmod(93.272 + 483202.018 * T, 360.0);
   
    // Sun's mean anomaly
    double Msun = fmod(357.529 + 35999.050 * T, 360.0);
   
    // Sun's equation of center
    C = (1.914 - 0.0048 * T) * sin(Msun * PI / 180) + (0.019 - 0.00004 * T) * sin(2 * Msun * PI / 180) + (0.0003 * sin(3 * Msun * PI / 180));

    // Apparent longitude of the Moon
    lambda = L0 + C;
   
    // Mean obliquity of the ecliptic
    double epsilon = 23.439292 * PI / 180;
   
    // Apparent latitude of the Moon
    beta = (0.0262 * sin(l * PI / 180) + 0.0002 * sin((l - M) * PI / 180) + 0.0003 * sin(M * PI / 180)) * PI / 180;

    *moonLatitude = beta;
    *moonLongitude = lambda;
}

int main() {
    double jd, moonLatitude, moonLongitude;

    printf("Enter the Julian Date: ");
    scanf("%lf", &jd);

    moonPosition(jd, &moonLatitude, &moonLongitude);

    printf("Moon Position (Latitude, Longitude): %lf, %lf\n", moonLatitude, moonLongitude);

    return 0;
}

This program calculates the approximate latitude and longitude of the moon for a given Julian Date (jd). It uses basic astronomical formulas to estimate the moon's position relative to the Earth. Keep in mind that professional libraries and algorithms are used for more accurate and precise astronomical calculations.

Grüße
Maximilian

h_c_greier · 27. Juli 2023

OK, nur damit das klar ist, ich will hier kein chatGPT Bashing betreiben.

<CODE....> Ui, pointers, brrrr *schüttel*

Naja das ist ja schon mal was! Ich habe das jetzt auf JS umgemodelt.
Das fmod ist bei mir range, macht dasselbe.

Code:

const PI = 3.14159265358979323846;
const DEGS = PI / 180;

function range(deg) {
  return (deg % 360 + 360) % 360;
}

function sin(x) {
  return Math.sin(x * DEGS);
}

// Function to calculate the position of the moon

function moonPosition(jd) {
    let T, L0, l, M, C, lambda, beta;
 
    // Julian centuries since J2000.0
    T = (jd - 2451545.0) / 36525.0;

    // Mean longitude of the Moon
    L0 = range(218.316 + 481267.881 * T);
 
    // Mean anomaly of the Moon
    M = range(134.963 + 477198.867 * T);
 
    // Mean elongation of the Moon
    l = range(93.272 + 483202.018 * T);
 
    // Sun's mean anomaly
    let Msun = range(357.529 + 35999.050 * T);
 
    // Sun's equation of center
    C = (1.914 - 0.0048 * T) * sin(Msun) + (0.019 - 0.00004 * T) * sin(2 * Msun) + (0.0003 * sin(3 * Msun));

    // Apparent longitude of the Moon
    lambda = range(L0 + C);
 
    // Mean obliquity of the ecliptic
    let epsilon = 23.439292;
 
    // Apparent latitude of the Moon
    beta = (0.0262 * sin(l) + 0.0002 * sin((l - M)) + 0.0003 * sin(M)) / DEGS;

    return [lambda, beta]
}

console.clear();
console.log(moonPosition(2451544.5));

Kann man z.B. hier testen (Copy+Paste)

Es verwendet scheinbar für die Fundamentalargumente die Zahlen von Meeus, hier nur mit linearem Term in T, was OK ist.
Dann weiter über die Mittelpunktsgleichung zum lambda.
Die Gleichung für beta ist mir schleierhaft, kommt auch nix Gescheites raus dabei.
Alles in allem natürlich ohne "perturbations", was natürlich große Abweichungen erzeugt. Die müsste man noch einbauen.

Mit dem Testdatum 1.1.2000 00:00 TD = JD 2451544.5 ergibt sich
[ 211.62682985234846, 1.5044265773227463 ]

Horizons sagt: [ 217.2843298, 5.2313466 ]

Die Abweichungen sind 5.66° in lambda und 3.73° in beta. Aber wie gesagt, man müsste es noch dazu bringen, Korrekturterme einzubauen. Das kann es sicher, wenn es die relevante Literatur dafür gelesen hat. Oder Webseiten mit Code.

cs,
harald

--

h_c_greier · 27. Juli 2023

Na gut, ich will mal nicht so sein und revidiere "völlig ungeeignet" zu "ziemlich ungeeignet".

cs,
harald

--

maximilian · 27. Juli 2023

Hallo!

Zitat von h_c_greier:
Na gut, ich will mal nicht so sein und revidiere "völlig ungeeignet" zu "ziemlich ungeeignet".

>ich: can you make the calculation more precise please (ich habe ihn das Programm schon vorher als JavaScript erzeugen lassen)

>ChatGPT: Certainly! We can improve the precision of the moon position calculation by using more accurate values for the astronomical parameters and incorporating additional terms in the formulas. Below is an updated JavaScript program with improved precision:

Code:

function moonPosition(jd) {
  // Julian centuries since J2000.0
  const T = (jd - 2451545.0) / 36525.0;

  // Mean elongation of the Moon
  const l = 218.316 + 481267.881 * T;

  // Mean anomaly of the Moon
  const M = 134.963 + 477198.867 * T;

  // Mean distance of the Moon from its ascending node
  const F = 93.272 + 483202.018 * T;

  // Mean longitude of the ascending node
  const Ω = 125.04452 - 1934.136261 * T;

  // Additional corrections
  const A1 = 119.75 + 131.849 * T;
  const A2 = 53.09 + 479264.290 * T;
  const A3 = 313.45 + 481266.484 * T;

  // Convert angles to radians
  const D2R = Math.PI / 180;
  const lrad = l * D2R;
  const Mrad = M * D2R;
  const Frad = F * D2R;
  const Ωrad = Ω * D2R;
  const A1rad = A1 * D2R;
  const A2rad = A2 * D2R;
  const A3rad = A3 * D2R;

  // Perturbations in longitude and latitude
  const Δλ = (-1.274 * Math.sin(Mrad - 2 * Frad) +
              0.658 * Math.sin(2 * Frad) -
              0.186 * Math.sin(Mrad) -
              0.059 * Math.sin(2 * Mrad - 2 * Frad) -
              0.057 * Math.sin(Mrad - 2 * Frad + A2rad) +
              0.053 * Math.sin(Mrad + 2 * Frad) +
              0.046 * Math.sin(2 * Frad - A1rad) +
              0.041 * Math.sin(Mrad - A2rad) -
              0.035 * Math.sin(Frad) -
              0.031 * Math.sin(Mrad + A2rad) -
              0.015 * Math.sin(2 * Mrad - 2 * Ωrad) +
              0.011 * Math.sin(Mrad - 4 * Frad));

  const Δβ = (-0.173 * Math.sin(Frad - 2 * Frad) -
              0.055 * Math.sin(Mrad - Frad - 2 * Frad) -
              0.046 * Math.sin(Mrad + Frad - 2 * Frad) +
              0.033 * Math.sin(Frad + 2 * Frad) +
              0.017 * Math.sin(2 * Mrad + Frad) +
              0.014 * Math.sin(Mrad - 2 * Ωrad + Frad) -
              0.011 * Math.sin(Mrad - Frad));

  // Mean obliquity of the ecliptic
  const ε = 23.439292 * D2R;

  // Corrected longitude and latitude
  const λ = (l + Δλ) % 360.0;
  const β = Δβ;

  return { latitude: β, longitude: λ };
}

// Example usage:
const jd = 2459322.5; // Replace this with the Julian Date you want to calculate for
const moonPos = moonPosition(jd);
console.log("Moon Position (Latitude, Longitude):", moonPos.latitude, ",", moonPos.longitude);

Geht doch!

Grüße
Maximilian

PS: Zum Glück verdiene ich mein Geld schon lange nicht mehr mit Softwareentwicklung, sonst müsste ich langsam Angst bekommen.

h_c_greier · 27. Juli 2023

Lutsch mich rund und nenn mich Bärbel!

Weißt du, was da herauskommt?
(JD 2459322.5 = 18.4.2021 00:00 TD)

Moon Position (Latitude, Longitude): 0.13043351268942663 , 98.14435327597312

Korrekte Werte: 1.8456777, 92.2761298
Mit anderen Worten: ziemlich weit daneben geraten. Certainly!

Und was zum

macht

hier??

cs,
harald

--

maximilian · 27. Juli 2023

Hallo!

Zitat von h_c_greier:
Und was zum macht hier??

Das ist in den meisten Programmlistings enthalten, die ich oben eingefügt habe. Hat vielleicht mit einem Teil der Software zu tun, die in der einfachen Version nicht enthalten ist, wie z.B. die Umrechung auf den Standort des Beobachters, die hier nirgends vorgenommen wird.
Das ist übrigens die „freie“ Version von ChatGPT, deren Datenbestand schon vor zwei Jahren eingefroren wurde. Die aktuelle Bezahlversion dürfte da um einiges weiter sein.

Grüße
Maximilian

PS: Wie ich es mir dachte, Epsilon hat mit der Umrechnung auf lokale Koordinaten zu tun.
>ich: Is it possible to compute this result for a specific observation position and time on the surface of the earth

> ChatGPT:
Yes, it is possible to compute the moon's position relative to a specific observation position and time on the surface of the Earth. To achieve this, we need to take into account the observer's geographic coordinates (latitude and longitude) and the local time.

Here's an updated JavaScript program that takes the observer's geographic coordinates (latitude and longitude) and the local time (in UTC) into account to calculate the moon's position:

Code:

function observerPosition(observerLat, observerLon, jd) {
  // Julian centuries since J2000.0
  const T = (jd - 2451545.0) / 36525.0;

  // Mean elongation of the Moon
  const l = 218.316 + 481267.881 * T;

  // Mean anomaly of the Moon
  const M = 134.963 + 477198.867 * T;

  // Mean distance of the Moon from its ascending node
  const F = 93.272 + 483202.018 * T;

  // Mean longitude of the ascending node
  const Ω = 125.04452 - 1934.136261 * T;

  // Additional corrections
  const A1 = 119.75 + 131.849 * T;
  const A2 = 53.09 + 479264.290 * T;
  const A3 = 313.45 + 481266.484 * T;

  // Convert angles to radians
  const D2R = Math.PI / 180;
  const lrad = l * D2R;
  const Mrad = M * D2R;
  const Frad = F * D2R;
  const Ωrad = Ω * D2R;
  const A1rad = A1 * D2R;
  const A2rad = A2 * D2R;
  const A3rad = A3 * D2R;

  // Perturbations in longitude and latitude
  const Δλ = (-1.274 * Math.sin(Mrad - 2 * Frad) +
              0.658 * Math.sin(2 * Frad) -
              0.186 * Math.sin(Mrad) -
              0.059 * Math.sin(2 * Mrad - 2 * Frad) -
              0.057 * Math.sin(Mrad - 2 * Frad + A2rad) +
              0.053 * Math.sin(Mrad + 2 * Frad) +
              0.046 * Math.sin(2 * Frad - A1rad) +
              0.041 * Math.sin(Mrad - A2rad) -
              0.035 * Math.sin(Frad) -
              0.031 * Math.sin(Mrad + A2rad) -
              0.015 * Math.sin(2 * Mrad - 2 * Ωrad) +
              0.011 * Math.sin(Mrad - 4 * Frad));

  const Δβ = (-0.173 * Math.sin(Frad - 2 * Frad) -
              0.055 * Math.sin(Mrad - Frad - 2 * Frad) -
              0.046 * Math.sin(Mrad + Frad - 2 * Frad) +
              0.033 * Math.sin(Frad + 2 * Frad) +
              0.017 * Math.sin(2 * Mrad + Frad) +
              0.014 * Math.sin(Mrad - 2 * Ωrad + Frad) -
              0.011 * Math.sin(Mrad - Frad));

  // Mean obliquity of the ecliptic
  const ε = 23.439292 * D2R;

  // Corrected longitude and latitude
  const λ = (l + Δλ) % 360.0;
  const β = Δβ;

  // Observer's position in radians
  const observerLatRad = observerLat * D2R;
  const observerLonRad = observerLon * D2R;

  // Hour angle
  const GMST0 = (280.46061837 + 360.98564736629 * (jd - 2451545.0)) % 360.0;
  const UT = (jd - Math.floor(jd + 0.5)) * 24.0; // Time in UTC
  let hourAngle = (GMST0 + observerLon - UT * 15) * D2R;
  hourAngle = (hourAngle + Math.PI) % (2 * Math.PI) - Math.PI; // Ensure it's within -π to +π

  // Observer's equatorial coordinates
  const α = Math.atan2(Math.cos(ε) * Math.sin(λ), Math.cos(β) * Math.sin(ε) - Math.sin(β) * Math.cos(ε) * Math.cos(λ));
  const δ = Math.asin(Math.sin(β) * Math.sin(ε) + Math.cos(β) * Math.cos(ε) * Math.cos(λ));

  // Rotate equatorial coordinates for the observer's location
  const H = hourAngle;
  const observerRightAscension = (α + observerLonRad - H) % (2 * Math.PI);
  const observerDeclination = δ;

  return { rightAscension: observerRightAscension, declination: observerDeclination };
}

// Example usage:
const jd = 2459322.5; // Replace this with the Julian Date you want to calculate for
const observerLat = 51.5074; // Replace this with the observer's latitude in degrees
const observerLon = -0.1278; // Replace this with the observer's longitude in degrees
const observerPos = observerPosition(observerLat, observerLon, jd);
console.log("Observer's Equatorial Coordinates (RA, Dec):", observerPos.rightAscension, ",", observerPos.declination);

In this updated version, the program calculates the observer's equatorial coordinates (right ascension and declination) based on their geographic coordinates (latitude and longitude) and the local time (in UTC). The equatorial coordinates represent the moon's position relative to the observer's location on the Earth's surface. Please note that the observer's position is given in degrees, and the program internally converts the angles to radians for calculations. Also, the program calculates the observer's local sidereal time (LST) to account for the rotation of the Earth and correctly align the equatorial coordinates with the observer's meridian.

As before, please keep in mind that this is still a simplified version, and for the highest accuracy, specialized astronomical libraries or tools should be used.

h_c_greier · 28. Juli 2023

Hallo Maximilian,

also echt jetzt, hast du den von dir oben geposteten Code mal getestet?
Syntaktisch zwar korrekt, aber der macht gar nix. Egal, welche Länge und Breite man eingibt, es kommen immer dieselben Werte heraus

JD = 2459322.5 = 18. 4. 2021 00:00 TD
Lat = 0, Lon = 0:
Observer's Equatorial Coordinates (RA, Dec): -1.377031789718942 , -0.6570398465100971
Lat = 50, Lon = 10:
Observer's Equatorial Coordinates (RA, Dec): -1.3770317897189432 , -0.6570398465100971
Lat = -50, Lon = -10:
Observer's Equatorial Coordinates (RA, Dec): -1.377031789718942 , -0.6570398465100971
usw.

Ich sag's ja, sobald das ein wenig komplexer wird, steht chatGPT "auf da Saaf", wie man hierzulande so schön sagt...
Und wenn ich die Machine erst mit 69 verschiedenen Anfragen "antrainieren" muss, damit sie mir endlich Korrektes liefert, da kann ich es gleich selber machen. Aber schließlich geht es ja hier genau darum.
Ist für mich immer noch PipiFax das Zeug. Reden wir in 10 Jahren weiter...

cs,
harald

--

SigvaldS · 28. Juli 2023

Nun ChatGPT wurde ja nicht fürs Coding entwickelt. Dafür gibt es bessere KIs. Ich denke Du unterschätzt den technischen Fortschritt. In 3 bis 5 Jahren sind wir wesentlich weiter.
CS Sigvald

P_E_T_E_R · 28. Juli 2023

Zitat von SigvaldS:
In 3 bis 5 Jahren sind wir wesentlich weiter.

Das ist ja auch immer der Standardspruch bei der Kernfusion, und zwar mittlerweile seit mehr als fünfzig Jahren ...

h_c_greier · 28. Juli 2023

Hallo Sigvald,

es ist schon interessant, wie schnell man bei einem anderen Thema landet. Ist schon OK

Zitat von SigvaldS:
In 3 bis 5 Jahren sind wir wesentlich weiter.

Das mag alles sein. Die Frage ist halt auch, in welcher Richtung? Und wie Peter bereits bemerkte ist das eine Standardphrase bei dem Thema.
Eine andere Standardphrase wurde auch schon gebracht: "Das ist ja die limitierte Version (xx), die aktuelle Bezahlversion dürfte da um einiges weiter sein". Auch das mag sein.

Nochmal: Darum geht es nicht! Die Aufgabe ist hier nicht zu ermitteln, ob chatGPT oder eine andere KI das Problem bewältigt, sondern ein Mensch wie du und ich, und vor allem wie die Herangehensweise bezüglich unterschiedlicher Genauigkeiten dabei ist/war.

Mit anderen Worten: Ich wolte eigentlich nur verschiedene Scripte (zum gegebenen Thema) vergleichen. Nach dem Motto "...in diesem Fall habe ich Meeus genommen und dies und das abgeändert"...

Noch lustiger wird es, wenn man dann Codes hier herein stellt und die nicht mal überprüft hat, ob sie denn funktionieren

I can't help falling in love....

Ich kann mich nur wiederholen: Gegeben ein konkretes Problem mit Vorgaben. Wenn man dann chatGPT peu à peu mit immer abgewandelteren Fragestellungen beibringen muss, was man genau will, und dieser Prozess dann länger dauert als wenn man es selbst macht, ist für mich der Benefit enden wollend. Hilfestellung, ja sicher.

Ein bekannter Außenminister sagte dereinst mal: "Excuse me, I am not convinced."
Und ich denke es ist durchaus angebracht, skeptisch zu sein.

cs,
harald

--

P_E_T_E_R · 28. Juli 2023

Hallo Harald,

den Code von Schlyter hast du ja schon und noch kompakter geht es auch nicht, ohne Verlust an Genauigkeit.

Darüber hinaus muss man sich dann etwa mit der Theorie von Brown befassen:

Ernest W. Brown: Theory of the Motion of the Moon

oder halt mit der rein phänomenologischen Implementierung von Meeus.

Wer sich nicht nur für den Code, sondern auch für die treibenden physikalischen Ursachen und die historischen Fortschritte im Verständnis interessiert, sollte vielleicht hier mal reinschauen:

Martin C. Gutzwiller: Moon-Earth-Sun: The oldest three-body problem

Gruß, Peter

h_c_greier · 29. Juli 2023

Zurück zum Thema. Ich habe nun die folgenden Scripte verglichen:

(x) O. Montenbruck/T. Pfleger: MiniMoon, Kap. 3.2 aus Astronomie mit dem Personal Computer
(x) P. Schlyter: The Moon's position, Computing planetary positions - a tutorial with worked examples
(x) O. Montenbruck: Die Mondbahn, Kap. 5 aus Grundlagen der Ephemeridenrechnung
(x) J. Meeus: Position of the Moon, Kap. 47 aus Astronomical Algorithms

Bei Meeus einmal mit 15 Termen, um mit Montenbrucks 'Grundlagen' besser vergleichen zu können, der auch 15 Terme (Länge) verwendet, und einmal mit allen 60 Korrekturtermen.

Die berechneten Werte dieser Skripte sind die geozentrischen ekliptikalen Koordinaten LBR. Diese wurden für den Zeitraum 1.1.1900 – 1.1.2100 mit den JPL Horizons Daten verglichen, insgesamt sind das 73050 Events. Die Berechnungszeitpunkte gelten jeweils für 00:00 TD (dynamische Zeit). Der Algorithmus 'MiniMoon' von Montenbruck/Pfleger liefert leider keine geozentrische Entfernung, hier wurde die Berechnungsmethode von den "Grundlagen" geklaut. Daher sind die Werte für den Radiusvektor bei 'MiniMoon' und den 'Grundlagen' gleich.

Die Fehler sind nachstehend in Bogenminuten gelistet, außer bei Meeus mit 60 Termen.

Code:

Ergebnisse 1900-2100, 73050 Events
==================================
Geozentrische ekliptikale Koordinaten
Schrittweite 1d, immer 00:00 TD

-----------------------------------------------------------
MiniMoon (Montenbruck/Pfleger Astronomie m. d. PC)
-----------------------------------------------------------
                  Fehler           Fehler          Fehler
Ekl. Länge          >2'             >3'              >4'
                  10.32%            1.91%           0.28%

Ekl. Breite        >0.5'            >0.6'           >0.7'
                   1.51%            0.39%           0.05%

Radiusvektor      >300km           >400km           >500km
                  7.04%            1.04%            0.02%
(Radiusvektor von den Grundlagen!)


-----------------------------------------------------------
Montenbruck (Grundlagen d. Ephemeridenrechnug)
-----------------------------------------------------------
                  Fehler           Fehler          Fehler
Ekl. Länge          >2'             >3'              >4'
                   7.99%           1.55%            0.20%

Ekl. Breite        >0.5'            >0.6'           >0.7'
                   1.35%            0.30%            0.05%

Radiusvektor      >300km           >400km           >500km
                  7.04%            1.04%            0.02%
                  
                  
-----------------------------------------------------------
Meeus (Astronomical Algorithms), 15 Terme (=wie Montenbruck)
-----------------------------------------------------------
                  Fehler           Fehler          Fehler
Ekl. Länge          >2'             >3'              >4'
                   7.76%           1.01%            0.08%

Ekl. Breite        >0.5'            >0.6'           >0.7'
                   6.47%            3.91%            2.49%

Radiusvektor      >300km           >400km           >500km
                  0.02%            0.00%            0.00%

 
-----------------------------------------------------------
Schlyter
-----------------------------------------------------------
                  Fehler           Fehler          Fehler
Ekl. Länge          >2'             >3'              >4'
                   21.4%           5.48%            0.87%

Ekl. Breite        >0.5'            >0.6'           >0.7'        >2'
                  68.55%           62.53%           56.58%       3.59%
                                                                
Radiusvektor      >300km           >400km           >500km       >1000km
                  34.82%           21.91%           13.49%       1.22%


-----------------------------------------------------------
Meeus (Astronomical Algorithms), alle 60 Terme
-----------------------------------------------------------
(Achtung: Bogensekunden!)
                  Fehler           Fehler          Fehler
Ekl. Länge         >10"             >15"            >20"
                  58.63%           29.22%           3.55%

Ekl. Breite        >2"             >3"              >4"
                   5.06%           0.76             0.14%

Radiusvektor      >30km            >40km            >50km
                  41.93%           6.00%            0.00%

Länge: Für 50% liegt der Fehler unter 11.7"
       Nur 1 Wert liegt außerhalb von 30".

===========
Performance
===========

Mittelwert aus je 20 Messungen für 73050 Berechnungen.

Code:

MiniMoon:       44ms
Grundlagen:     65ms
Meeus 15 Terme: 342ms
Meeus 60 Terme: 645ms
Schlyter:       79ms

Hier ist Meeus der klare Verlierer. Bei 60 Termen von der Genauigkeit unschlagbar, aber langsam. Muss mal schauen, was man da verbessern kann...

In Kombination Genauigkeit+Geschwindigkeit liefern 'MiniMoon' und die 'Grundlagen' sehr brauchbare Ergebnisse. Schlyter ist solala würde ich sagen. Meeus ist bei 15 Termen relativ schlecht bei der Breite B, dafür top beim Radiusvektor.
Bei 60 Termen hält er sein Versprechen aus dem Buch mit ca. 4". Für die Länge L sind aber lediglich 41.37% der Werte unter 10", aber wer wird denn so kleinlich sein.

cs,
harald

--

h_c_greier · 31. Juli 2023

Wie versprochen zu den Mond-Algorithmen eine kleine Seite.
Ich habe den Vergleichs-Zeitraum jetzt auf 400 Jahre erhöht, 1800-2200.
Ladezeit kann ein bisschen dauern, weil die JPL Daten fix in einer JS Datei geladen werden (da ich keinen API Zugriff auf diese Daten habe).

Mondkoordinaten mit verschiedenen Algorithmen - ein Vergleich

Vel Spaß, cs,
harald

--

SigvaldS · 31. Juli 2023

Ich werde es mal damit versuchen:
Genauigkeit von 0,01 Bogensekunden
- Verwendete Bibliothek: NOVAS
- Berechnungsmethode: IAU 2000A Model
- Abweichung: Durchschnittlich etwa 0,005 Bogensekunden
Läßt sich bestimmt mit Python realisieren

cs, Sigvald

Mondposition - Coding Challenge

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied

Aktives Mitglied