EphemPedia

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
====== Der Julianische Tag JD ======

Die Ermittlung des Julianischen Tages $JD$ ist für viele astronomische Berechnungen essentiell. Auf diesen Seiten wird sehr häufig der Wert $T$ verwendet. Dieser bezeichnet die //julianischen Jahrhunderte// (= 36525 Tage) bezüglich einer Epoche, z.B. $J1900$ oder $J2000$.

Bezüglich Epoche $J2000$

{{anchor:jult2000}}
\[T = \frac{JD - 2451545.0}{36525}\tag{1}\] 

oder auch bzgl. Epoche $J1900$

{{anchor:jult1900}}
\[T = \frac{JD - 2415020.0}{36525}\tag{2}\] 

Um diesen Berechnungsparameter $T$ zu bestimmen, muss man also zuerst den julianischen Tag $JD$ kennen.

<WRAP center round tip 100%>
In der Fachliteratur liest man oft den Begriff Julianisches //Datum//, das hat sich leider so eingebürgert. Ein julianisches //Datum// ist ein Datum im Julianischen Kalender, also vor dem 4.10.1582. Ein gregorianisches //Datum// ist ein Datum im Gregorianischen Kalender, also nach dem 15.10.1582. Wir beschränken uns hier auf die Bezeichnung //Julianischer Tag// mit der Abkürzung $JD$.
</WRAP>

Der julianische Tag $JD$ ist die fortlaufende Zählung der Tage seit dem Datum 1.1.–4712 12:00 $UT$ (Universal Time, Weltzeit). Man beachte, dass die astronomische Jahreszählung dabei das Jahr "0" beinhaltet. Dadurch ist sichergestellt, dass die Schaltjahresregel des julianischen Kalenders auch für negative Jahre korrekt funktioniert, da weiterhin alle durch 4 teilbaren Jahre ein Schaltjahr sind. Der bürgerliche Kalender hingegen kennt kein "Jahr 0", dort folgt auf den 31.12.–0001 der 1.1.0001.
Siehe auch dazu den Beitrag zum [[datumseingabe#schaltjahr|Schaltjahr]].

==== Gregorianische Kalenderreform ====

Die 10 Tage vom 5.10.1582 bis 14.10.1582 wurden im Zuge der gregorianischen Kalenderreform ausgelassen, wobei aber die Fortschreibung der Wochentage beibehalten wurde. Auf **Donnerstag** den 4.10.1582 folgte **Freitag** der 15.10.1582.

Im folgenden sind alle Divisionen mittels der Funktion ''trunc(...)'' **Ganzzahl**-Divisionen ohne Rest! Programmierer können hier z.B. mit ''Math.floor(...)'' (JavaScript) rechnen oder entsprechend der jeweiligen Programmiersprache eine ähnliche Funktion nehmen. In Python 3 ist die Ganzzahl-Division mittels \( // \) möglich (Doppelter Schrägstrich).

Die nachfolgende Berechnungsmethode stammt aus [[literaturhinweise#books_meeus|J. Meeus, Astronomical Algorithms]].

{{anchor:jd_calc}}

===== Berechnung des JD =====

  * Es sei $J$ = Jahr, $M$ = Monat (1 bis 12) und $D$ = Tag im Monat.
  * Ortszeiten müssen in Weltzeit $UT$ umgerechnet werden!
  * Der Tagesbruchteil wird als Kommawert dem Wert $D$ angehängt (siehe Beispiele).
    * Soll der $JD$ für 00:00 $UT$ berechnet werden, muss natürlich kein Tages-Bruchteil ermittelt werden.
  * Wenn der Monat **Januar** (1) oder **Februar** (2) ist, vergrößert man $M$ um $12$ und verringert $J$ um $1$. Für alle anderen Monate ändert sich nichts.
  * Für ein Datum im //julianischen// Kalender (vor dem 4.10.1582) ist $B = 0$.
  * Für ein Datum im //gregorianischen// Kalender (ab dem 15.10.1582) berechnet man

\[\begin{align}
A &= \textrm{trunc}\left(\frac{J}{100}\right)\\
B &= 2 - A + \textrm{trunc}\left(\frac{A}{4}\right)
\end{align}\tag{3}\]

Der Julianische Tag hat dann den Wert:

\[\begin{align}
JD &= \textrm{trunc}(365.25 \cdot (J + 4716)) \\
&+ \textrm{trunc}(30.6001 \cdot (M + 1)) \\
&+ D + B - 1524.5
\end{align}\tag{4}\]

Hierbei wird die ''trunc''- bzw. manchmal die ''int''-Funktion verwendet, die nicht rundet, sondern die Nachkommastellen abschneidet, [[:mathematische_grundlagen#trunc_und_frac_funktion|siehe hier]].

<WRAP center round important 100%>
Der Julianische Tag $JD$ sollte mindestens mit 5 Nachkommastellen angegeben werden, denn $0\overset{d}{.}00001$ Tage sind $0\overset{s}{.}864$ Sekunden.\\ 
Für die nachstehenden Berechnungen gilt $JD = 0$ für den \( 1.1.-4712 = 1.1.4713\;v.Chr.\) \\
Für Kalenderdaten //davor// ist der Algorithmus **ungültig**.
</WRAP>

<WRAP center round info 100%>
Bei der Berechnung von $JD$ kann anstatt der ''trunc''-Funktion auch die ''floor''-Funktion verwendet werden, da im Algorithmus nur positive Zahlen auftauchen.
</WRAP>

<WRAP center round tip 100%>
Weiters ist im Zeitraum vom 1.3.1900 bis zum 28.2.2100 der Wert von $B$ immer $B = -13$ und muss nicht extra berechnet werden.
</WRAP>

<WRAP center round box 100%>
==== Beispiel 1 ====

{{:beispiel_calculator.png?nolink| }} **Man ermittle den Julianischen Tag am 15.4.2023 um 22:15 mitteleuropäische Sommerzeit ($MESZ$).
**
  * $J = 2023$, $M = 4$. Für Monat April (4) muss nichts geändert werden.
  * Tag $D = 15$, Uhrzeit 22:15 $MESZ$ wird umgerechnet in 20:15 $UT$, also $20^h15^m = 20 + \frac {15}{60} = 20.25^{h}$.
  * Tages-Bruchteil ist demnach $\frac {20.25}{24} = 0.84375$, also $D = 15.84375$
  * Man hat ein Datum im **gregorianischen** Kalender, daher folgt

\(\begin{align}
A &= \textrm{trunc}\left(\frac{2023}{100}\right) = 20\\
B &= 2 - A + \textrm{trunc}\left(\frac{20}{4}\right)\\
&= 2 - 20 + 5 = -13
\end{align}\)

\(\begin{align}
JD &= \textrm{trunc}(365.25 \cdot (2023 + 4716))\\
&+ \textrm{trunc}(30.6001 \cdot (4 + 1))\\
&+ 15.84375 -13 - 1524.5\\
&= 2460050.34375
\end{align}\)
</WRAP>

----

<WRAP center round box 100%>
==== Beispiel 2 ====

{{:beispiel_calculator.png?nolink| }} **Man ermittle den Julianischen Tag am 4.7.1054 um 18:24 $MEZ$ (Supernova von 1054).**

  * $J = 1054$, $M = 7$. Für Monat Juli (7) muss nichts geändert werden.
  * Tag $D = 4$, Uhrzeit 18:24 $MEZ$ wird umgerechnet in 17:24 $UT$, also $17^h 24^m = 17 + \frac{24}{60} = 17.4^{h}$.
  * Tages-Bruchteil ist demnach $\frac{17.4}{24} = 0.725$, also $D = 4.725$
  * Man hat ein Datum im **julianischen** Kalender, daher folgt $B = 0$

\(\begin{align}
JD &= \textrm{trunc}(365.25 \cdot (1054 + 4716))\\
&+ \textrm{trunc}(30.6001 \cdot (7 + 1))\\
&+ 4.725 - 0 - 1524.5\\
&= 2106216.22500
\end{align}\)
</WRAP>

<WRAP center round box 100%>
==== Beispiel 3 ==== 

{{:beispiel_calculator.png?nolink| }} **Man ermittle den Julianischen Tag am 27.1.333 um 15:00 $UT$.**

  * $J = 333$, $M = 1$.
  * Weil Monat Januar (1) rechnet man mit: $M + 12 = \color{#276eff}{13}$, $J - 1 = \color{#cc0000}{332}$
  * Tag $D = 27$, Uhrzeit 15:00 $UT$, also $15^h 00^m = 15.0^h$.
  * Tages-Bruchteil ist demnach $\frac{15}{24} = 0.625$, also $D = 27.625$
  * Man hat ein Datum im **julianischen** Kalender, daher folgt $B = 0$

\(\begin{align}
JD &= \textrm{trunc}(365.25 \cdot (\color{#cc0000}{332} + 4716))\\
&+ \textrm{trunc}(30.6001 \cdot (\color{#cc0000}{\color{#276eff}{13}} + 1))\\
&+ 27.625 - 0 - 1524.5\\
&= 1842713.12500
\end{align}\)

</WRAP>

===== Tabelle =====

Mit der nachstehenden Tabelle kann man selbst geschriebene Programmcodes überprüfen. Negative Jahre sind in astronomischer Schreibweise notiert.

{{tablelayout?rowsHeaderSource=Auto&colwidth="210px,120px,210px,120px"&float=center}}
^  Tabelle 1  ||||
^  Zeitpunkt in $UT$  ^  JD         ^  Zeitpunkt in $UT$   ^  JD         ^
|  01.01.2000, 12:00  |  2451545.0  |  31.12.1600, 00:00   |  2305812.5  |
|  01.01.1999, 00:00  |  2451179.5  |  10.04.0837, 07:12   |  2026871.8  |
|  27.01.1987, 00:00  |  2446822.5  |  31.12.–123, 00:00   |  1676496.5  |
|  19.06.1987, 12:00  |  2446966.0  |  01.01.–122, 00:00   |  1676497.5  |
|  27.01.1988, 00:00  |  2447187.5  |  12.07.–1000, 12:00  |  1356001.0  |
|  19.06.1988, 12:00  |  2447332.0  |  29.02.–1000, 00:00  |  1355866.5  |
|  01.01.1900, 00:00  |  2415020.5  |  17.08.–1001, 21:36  |  1355671.4  |
|  01.01.1600, 00:00  |  2305447.5  |  01.01.–4712, 12:00  |  0.000000   |

===== Javascript =====

<code JavaScript jd.js [enable_line_numbers="true", start_line_numbers_at="1", highlight_lines_extra="28"]>
// Julianischen Tag JD aus Datum und Uhrzeit berechnen.
// Jahre vor Christi Geburt sind astronomisch um 1 größer.
// Bsp.: bürgerlich 1.1.1563 v.Chr. = 1.1.-1562 astronomisch.
// Die Eingabe erfolgt IMMER nach astronomischer Definition.
// Der Algorithmus verwendet nur positive Zahlen, man kann daher
// mit Math.floor rechnen.
function getJD(yrs, mth, dys, hrs, mins, secs) {
  let q, a, b;
  // Wenn der Monat Januar (1) oder Februar (2) ist, wird die
  // Jahreszahl um 1 vermindert und die monatszhal um 12 erhöht.
  if (mth <= 2) {
      yrs--;
      mth += 12;
  }
  // Bestimmung eines Hilfswertes, mit dem zwischen julianischem
  // und gregorianischem Kalender unterschieden werden kann.
  q = 10000*yrs + 100*mth + dys;
  if (q > 15821004) {
      // Gregorianischer Kalender
      a = Math.floor(yrs/100);
      b = 2 - a + Math.floor(a/4);
  } else {
      // Julianischer Kalender
      b = 0;
  }
  // Dem Tag den Tages-Bruchteil hinzufügen
  dys += (hrs + mins/60 + secs/3600)/24;
  // Der Faktor 30.6001 MUSS so bleiben, 30.6 ist nicht ausreichend!
  return Math.floor(365.25*(yrs + 4716)) + Math.floor(30.6001*(mth + 1)) + dys + b - 1524.5;
}

</code>

<WRAP center round important 100%>
Der hier angegebene Javascript gibt **keine** Fehlermeldung aus, wenn ein Datum zwischen dem 4.10.1582 und dem 15.10.1582 angegeben wird!

  * Der 4.10.1582 um 00:00 ergibt JD = 2299159.5
  * Der 15.10.1582 um 00:00 ergibt JD = 2299160.5
  * Tage //zwischen// diesen Daten gab es nicht, die Rückgabe für z.B. 8.10.1582 um 00:00 lautet JD = 2299153.5. Dies müsste durch eine Fehlermeldung abgefangen werden!
</WRAP>


===== Modifizierter julianischer Tag =====

Der julianische Tag $JD$ hat für heutige Daten bereits 12 Stellen, wenn man mindestens 5 Kommastellen berücksichtigt. So ist z.B. die Epoche J2000 gegeben durch

1.1.2000 um 12:00 Weltzeit ($UT$): \(JD = 2451545.00000\)

Wie man sieht, wechselt $JD$ immer **mittags** (12:00 $UT$) des jeweiligen Tages zum nächsten Tag. Damit man nicht mit so vielen Stellen rechnen muss, wurde der sogenannte modifizierte julianische Tag $MJD$ eingeführt. Dieser beginnt am 17.11.1858 um 00:00 $UT$, wechselt also um **Mitternacht** zum nächsten Tag.

Es gilt die Umrechnung

$MJD = JD - 2400000.5\tag{5}$

Der 1.1.2000 um 12:00 $UT$ entspricht also dem modifizierten julianischen Tag

$MJD = 2451545.0 - 2400000.5 = 51544.5$

===== Umrechnung von JD in ein Kalenderdatum =====

Mit dem folgenden Algorithmus kann ein Zeitpunkt, der in julianischen Tagen $JD$ gegeben ist, in ein Kalenderdatum zurückgerechnet werden. Der Algorithmus stammt von J. Meeus aus [[:literaturhinweise#books_meeus|Astronomical Algorithms]] und gilt für Kalenderdaten vor und nach unserer Zeitrechnung (d.h. v.Chr. und n.Chr.), **nicht jedoch** für negative julianische Tage.

Man berechnet mithilfe der Funktionen [[:mathematische_grundlagen#trunc_und_frac_funktion|trunc und frac]]:

  * Addiere $+0.5$ zum gegebenen julianischen Tag
  * Der ganzzahlige Anteil der erhaltenen Zahl sei $Z = \textrm{trunc}(JD)$
  * Der Nachkommaanteil der erhaltenen Zahl sei $F = \textrm{frac}(JD)$
  
Als nächstes ermittelt man den Wert $A$ zu

  * Wenn $Z \lt 2299161$: $A = Z$
  * Wenn $Z \ge 2299161$: $\alpha = \textrm{trunc}\left(\frac{Z - 1867216.25}{36524.25}\right)$ und damit $A = Z + 1 + \alpha - \textrm{trunc}\left(\frac{\alpha}{4}\right)$

Man berechnet nun sukzessive die Werte

\[\begin{align}
B &= A + 1524\\
C &= \textrm{trunc}\left(\frac{B - 122.1}{365.25}\right)\\
D &= \textrm{trunc}(365.25\cdot C)\\\\
E &= \textrm{trunc}\left(\frac{B - D}{30.6001}\right)\\
\end{align}\tag{6}\]

Der Tag $d$ des Monats, in dezimaler Form, ist nun gegeben durch

$$d = B - D - \textrm{trunc}(30.6001\cdot E) + F\tag{7}$$

<WRAP center round important 100%>
Die Konstante $30.6001$ darf hier nicht verändert werden, z.B. zu $30.6$. Dies würde falsche Werte liefern!
</WRAP>

Die Nummer $m$ des Monats wird berechnet aus 
\[m = \begin{cases}
E - 1 \\ E - 13
\end{cases}
\quad \textsf{falls} \quad
\begin{matrix}
E < 14 \\ E = 13\; \textsf{oder}\; E = 14
\end{matrix}
\tag{8}\]

Die Jahreszahl $j$ wird berechnet aus
\[j = \begin{cases}
C - 4716 \\ C - 4715
\end{cases}
\quad \textsf{falls} \quad
\begin{matrix}
m \gt 2 \\ m = 1\; \textsf{oder}\; m = 2
\end{matrix}\tag{9}\]

<WRAP center round box 100%>
==== Beispiel 4 ====

**Man berechne das Kalenderdatum für den julianischen Tag** $JD = 2460050.34375$.\\
(Rückrechnung von [[julianischer_tag_jd#beispiel_1|Beispiel 1]])

----

Addieren von $0.5$ zum $JD$, daher

\(\begin{align}
JD &= 2460050.34375 + 0.5\\
   &= 2460050.\color{#ff0000}{8}4375
\end{align}\)

Der ganzahlige Anteil und der Nachkommaanteil sind dann

$Z = \textrm{trunc(2460050.84375)} = 2460050$\\
$F = \textrm{frac(2460050.84375)} = 0.84375$

Hier ist $Z \gt 2299161$, daher erhält man

\(\begin{align}
\alpha &= \textrm{trunc}\left( \frac{2460050 - 1867216.25}{36524.25} \right)\\
&=16\\
A &= Z + 1 + 16 - \textrm{trunc}\left( \frac{16}{4} \right)\\
&=2460063
\end{align}\)

Die Werte $B, C, D$ und $E$ ergeben sich zu

\(\begin{align}
B &= 2460063 + 1524 = 2461587\\
C &= \textrm{trunc}\left( \frac{2461587 - 122.1}{365.25} \right)\\
  &= 6739\\
D &= \textrm{trunc}\left( 365.25\cdot 6739 \right)\\
  &= 2461419\\
E &= \textrm{trunc}\left( \frac{2461587 - 2461419}{30.6001} \right)\\
  &= 5
\end{align}\)

Den Tag im Monat erhält man in dezimaler Form zu

\(\begin{align}
d &= 2461587 - 2461419\\
   &- \textrm{trunc}\left( 30.6001\cdot 5 \right)\\
   &+ 0.84375\\
   &= 15.84375
\end{align}\)

Weil $E = 5 \lt 14$ ist ergibt sich die Monatszahl zu

$m = 5 - 1 = 4$, also April.

Schließlich erhält man die Jahreszahl mit $m \gt 2$ als

$j = 6739 - 4716 = 2023$

Den Nachkommawert des Tages sollte man nun noch umrechnen in Stunden/Minuten/Sekunden:

\(\begin{align}
d &= 15\overset{d}{.}84375\\
h  &=\textrm{frac}(15.84375)\cdot 24\tfrac{h}{d} = 20\overset{h}{.}25\\
   & \textrm{trunc}(20.25) = 20^{h}\\
   & \textrm{frac}(20.25) \cdot 60\tfrac{m}{h}= 15^{m}
\end{align}\)

Es ergibt sich der 15. April 2023 um 20:15 $UT$. Dieser Wert kann dann an die Zeitzone angepasst werden, z.B. für 

  * mitteleuropäische Zeit: $MEZ = UT + 1^{h} = \textrm{21:15} \;MEZ$
  * mitteleuropäische Sommerzeit: $MESZ = UT + 2^{h} = \textrm{22:15} \;MESZ$
  * usw.
</WRAP>