Delphi-PRAXiS - Delphi Astro-Daten

Delphi-PRAXiS (https://www.delphipraxis.net/forum.php)

- Neuen Beitrag zur Code-Library hinzufügen (https://www.delphipraxis.net/33-neuen-beitrag-zur-code-library-hinzufuegen/)

- - Delphi Astro-Daten (https://www.delphipraxis.net/145690-astro-daten.html)

Hallo,
im Laufe der Zeit haben sich bei mir einige Funktionen zur Berechnung astronomischer Daten gesammelt, die ich nun in eine Unit gepackt habe :

Tag im Jahr, Woche im jahr, Schaltjahr(boolean), Sommerzeit(boolean), Jahreszeit,
Feiertage (in Abhängigkeit vom Bundesland), Sternzeichen ...
Für Mond und Sonne : -Aufgang, Untergang, Höchststand,
Mondphase, Mondalter, nächste und vorige Mondphase ...

Funktionen :

Delphi-Quellcode:

			function GetDayOfYear(CDate:TDateTime):Integer;

function GetDaysPerYear(CDate:TDateTime):Integer;

function IsLeapYear(CDate:TDateTime):boolean;

function GetWeekOfYear(CDate:TDateTime):Integer;

function GetWeeksPerYear(CDate:TDateTime):Integer;

function GetDaysPerMonth(CDate:TDateTime):Integer;

function GetFirstDayOfWeek(CDate:TDateTime; DayIndex:Integer):TDateTime;

function IsSummertime(CDate:TDateTime):boolean;

function GetHolidayIndex(CDate:TDateTime; Land:TdeState):integer;

function last_phase(date:TDateTime; phase:TMoonPhase):TDateTime;

function next_phase(date:TDateTime; phase:TMoonPhase):TDateTime;

function age_of_moon(date: TDateTime):extended;

function current_phase(date:TDateTime):extended;

function moon_distance(date: TDateTime): extended;

function lunation(date:TDateTime):integer;

function sun_distance(date: TDateTime): extended;

function nextperigee(date:TDateTime):TDateTime;

function nextapogee(date:TDateTime):TDateTime;

function StartSeason(year: integer; season:TSeason):TDateTime;

function Eclipse(var date:TDateTime; sun:boolean):TEclipse;

function NextEclipse(var date:TDateTime; sun:boolean):TEclipse;

function Sun_Rise(date:TDateTime; latitude, longitude:extended):TDateTime;

function Sun_Set(date:TDateTime; latitude, longitude:extended):TDateTime;

function Sun_Transit(date:TDateTime; latitude, longitude:extended):TDateTime;

function Moon_Rise(date:TDateTime; latitude, longitude:extended):TDateTime;

function Moon_Set(date:TDateTime; latitude, longitude:extended):TDateTime;

function Moon_Transit(date:TDateTime; latitude, longitude:extended):TDateTime;

function GetSternzeichen(const CDat:TDateTime):Integer;

function GetSeason(CDat:TDate):String;

function StartDateSeason(CDat:TDate; Season:TSeason): TDate;

function GetMoonPhase(const Dat:TDateTime): String;

function GetMoonPhaseNum(Age : extended):Integer;

function GetMoonPhaseConst(Age : extended):TMoonPhase8;

function DateTimeReal(DtTm : TDateTime; Long : extended):TDateTime;

function DateTimeTZ(DtTm : TDateTime; Hour : ShortInt):TDateTime;

im Anhang :
- die Unit : AstroUnit
- ein Demo zur Übersicht
- ein Screenshot vom Demo

falls Ihr noch Funktionen vermisst >>> lässt sich ja noch einfügen

--> 21.12.2013 : Version 4 angefügt (Astro4.rar) :
hinzugekommen sind Berechnungen zum "Blue Moon":
function BlueMoon . . . - hier wird auf vier Vollmonde in einer Jahreszeit geprüft, der
dritte Vollmond ist dann der Blue Moon.
Im Aufruf der Funktion kann dann noch festgelegt werden, ob der
vergangene Winter oder der kommende Winter berücksichtigt wird,
geprüft wird über vier Jahreszeiten.
function Double Moon . . . - hier wird auf zwei Vollmonde in einem Monat geprüft, je nach
Definition (es gibt mehrere) ist dann der zweite Vollmond
(30. od. 31. eines Monats) der Blue Moon.
-- allg. Überarbeitung

-- in Kürze : Auswahl der Berechnungen zu Sonnenstand, Auf-Untergang nach
realer (-0,83333°), bürgerlicher(-6°), nautischer(-12°), astronomischer(-18°) Dämmerung --> erledigt.

die Funktionen Sun_Rise ... und Sun_Set... erhalten nun einen weiteren Parameter vom Typ TCalcType (ctNull, ctGeneral, ctZivil, ctNautic, ctAstronomical)
Diese Parameter berechnen den Sonnen-Auf- bzw. Untergang nach einer Winkelabweichung von (0°, -0,8333°, -6°, -12°, -18°)
0° --> theor. Werte
-0,8333° allg. gültige Berechnung zu Soonen-Auf und Untergang
-6° bürgerliche Dämmerung
-12° nautische Dämmerung
-18° astronomische Dämmerung

Delphi-Quellcode:

			function Jul_Date(Year, Month, Day, Houre, Minute, Second : Word) : Extended;           // Julianisches Datum [JD]

function Jul_Day(JulianDate : Extended) : Extended;                                     // Julianische Tageszahl [n]

function TimeZoneBias:longint;                                                          // TimeZone

function TransformDate(Datum: TDatetime): TDateTime;                                    // Umwandlung TDateTIME

function Julian_Date(Date : TDateTime): Extended;                                       // Julianisches Datum [JD, nach 15.10.1582]

function Delphi_Date(J_Date : Extended): TDateTime;                                     // Delphi Datum

function Star_Time(Date : TDateTime): Extended;                                         // Sternenzeit

function DayOfYear(Date : TDateTime): Integer;                                          // Tag im Jahr

function DaysPerYear(Date : TDateTime): Integer;                                        // Schaltjahr (?)

function IsLeapYear(Date : TDateTime): Boolean;                                         // Woche im Jahr

function WeekOfYear(Date : TDateTime): Integer;                                         // akt. Woche im jahr (KW)

function WeeksPerYear(Date : TDateTime): Integer;                                       // Anzahl der Wochen im  Jahr

function DaysPerMonth(Date : TDateTime): Integer;                                       // Anzahl Tage im Monat

function FirstDayOfWeek(Date : TDateTime; DayIndex : Integer): TDateTime;               // Erster Tag in der Woche

function DayFromDate(Date : TDate): Integer;                                            // Tag aus Datum

function IsSummertime(Date : TDateTime): Boolean;                                       // Sommerzeit (?)

function GetHolidayIndex(Date : TDateTime; Land : TdeState): Integer;                   // Feiertage (--> Index)

procedure calc_geocentric(var coord : t_coord; Date : TDateTime);                       // Rektaszension, Deklination

function sun_coordinate(Date : TDateTime): t_coord;                                     // Koordinaten der Sonne

function moon_coordinate(Date : TDateTime): t_coord;                                    // Koordinaten des Mondes

procedure calc_phase_data(Date : TDateTime;

                          phase : TMoonPhase; var jde, kk, m, ms, f, o, e: Extended);   // Daten für Mondphase

function nextphase(Date : TDateTime; phase : TMoonPhase): TDateTime;                    // nächste MondPhase, Berechnung

function last_phase(Date : TDateTime; phase : TMoonPhase): TDateTime;                   // vorige Mondphase, Ausgabe

function next_phase(Date : TDateTime; phase : TMoonPhase): TDateTime;                   // nächste Mondphase, Ausgabe

function moon_phase_angle(Date: TDateTime): Extended;                                   // Mondphase, Winkel

function age_of_moon(Date: TDateTime): Extended;                                        // Mondalter in Tagen

function current_phase(Date : TDateTime): Extended;                                     // aktuelle Mondphase

function moon_distance(Date: TDateTime): Extended;                                      // Entfernung zum Mond

function lunation(Date: TDateTime): Integer;                                            // Mondwechsel, synodische Umlaufzeit (29,530589 d), Bezug 16.01.1923

function sun_distance(Date : TDateTime): Extended;                                      // Entfernung zur Sonne

function sun_diameter(Date : TDateTime): Extended;                                      // rel. Sonnen-Durchmesser

function moon_diameter(Date : TDateTime): Extended;                                     // rel. Mond-Durchmesser

function nextXXXgee(Date : TDateTime; apo: Boolean): TDateTime;                         // Berechnung Apogee, Perigee

function nextperigee(Date : TDateTime): TDateTime;                                      // Perigee, Ausgabe

function nextapogee(Date : TDateTime): TDateTime;                                       // Apogee, Ausgabe

function StartSeason(year : Integer; season : TSeason): TDateTime;                      // Anfang d. Jahreszeiten

function Eclipse(var Date : TDateTime; sun : Boolean) : TEclipse;                       // Finsternis

function NextEclipse(var Date : TDateTime; sun : Boolean): TEclipse;                    // nächste Finsternis

procedure correct_position(var position :t_coord; Date : TDateTime;

                               Latitude, Longitude, Height: Extended);                  // Positionsberechnungen

function Calc_Set_Rise(Date : TDateTime; Latitude, Longitude : Extended;

                       sun: Boolean; kind: T_RiseSet): TDateTime;                       // Auf- Untergang, Berechnungen

function Sun_Rise(Date : TDateTime; Latitude, Longitude : Extended;

                  CalcType : TCalcType): TDateTime;                                     // Sonnenaufgang

function Sun_Set(Date : TDateTime; Latitude, Longitude : Extended;

                  CalcType : TCalcType): TDateTime;                                     // Sonnenuntergang

function Sun_Transit(Date : TDateTime; Latitude, Longitude : Extended): TDateTime;      // Sonnenhöchststand

function Moon_Rise(Date : TDateTime; Latitude, Longitude : Extended): TDateTime;        // Mondaufgang

function Moon_Set(Date : TDateTime; Latitude, Longitude : Extended): TDateTime;         // Monduntergang

function Moon_Transit(Date : TDateTime; Latitude, Longitude : Extended): TDateTime;     // Mondhöchststand

function GetSternzeichen(const Date : TDateTime): Integer;                              // Sternzeichen --> uTable - Sternzeichen : array[1..12] of String

function GetSeason(Date : TDate): String;                                               // Jahreszeit

function StartDateSeason(Date : TDate; Season : TSeason): TDate;                        // Anfangsdatum für Jahreszeiten

function GetMoonPhase(const Date : TDateTime): String;                                  // Mondphase (String)

function GetFullMoonPhase(const Date : TDateTime): Boolean;                             // Vollmond ?

function GetMoonPhaseNum(Age : Extended): Integer;                                      // Mondphase (Integer, 1 .. 8)

function DateTimeReal(DtTm : TDateTime; Long : Extended): TDateTime;                    // TDateTime an der aktuellen Position

function DateTimeTZ(DtTm : TDateTime; Hour : ShortInt): TDateTime;                      // TDateTime in der Zeitzone

procedure InitLocale;                                                                   // lokale Einstellungen TDateTime

function BlueMoon(Year : Word; WinterBefore : Boolean): TDateTime;                      // Datum BlueMoon --> 4 Vollmonde in einer Jahreszeit

function DoubleMoon(Year, Month : Word): TDateTime;                                     // Datum zweiter Vollmond in einem Monat

Als kleine Anmerkung:

Delphi-Quellcode:

			uses

  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

  Dialogs, StdCtrls, ShellAPI, Registry, ShlObj, ComCtrls, DateUtils,

  ExtCtrls;

Was hältst du davon die Abhängigkeiten so weit wie möglich zu reduzieren? Ich denke nicht, dass Units wie Forms, ExtCtrls und Co. hier was verloren haben. Mit Free Pascal für Windows genügt zum Beispiel folgender Uses Abschnitt (müsste in Delphi genauso genügen):

Delphi-Quellcode:

			uses

  SysUtils, Classes, DateUtils, Windows;

Ich musste zwar noch den Typ TDate definieren, der bei Delphi (zumindest laut Online Hilfe) in der System Unit rumkurvt, bei Free Pascal allerdings nur von Lazarus in der Controls Unit definiert wird, aber danach kompilierts. Unter nicht Windows Systemen müsste man größere Anpassungen vornehmen, aber für Windows kompiliert sie ;)

Gruß,
Sven

Hallo,
@JamesTKirk : Abhängigkeiten sind reduziert, hatte ich vergessen, da ich
(zur besseren Kontrolle) das ganze erst mal visuell gemacht habe (DEMO).

:zwinker:

Nicht schlecht. So wa shabe ich schon lange mal gesucht, insbesondere wegen der Mondphasen usw.

Michael hat geschrieben:

Zitat:

Nicht schlecht. So wa shabe ich schon lange mal gesucht, insbesondere wegen der Mondphasen usw.

Gute Arbeit!
Ich habe lange nach den Berechnungen der Jahreszeiten gesucht.
Gibt es da noch Quellen zum Nachlesen?

Gruß

Wolfgang

Hallo

@Wolfgang : die Berechnungen basieren auf MEEUS (einfach mal googeln).

Viel der Berechnungen und Konstanten hab' ich mal bruchstückweise bekommen
und immer mal wieder (wenn ich mal Lust und Zeit hatte ...) vervollständigt.
Derzeit arbeite ich noch an einer Funktion zur Rückgabe von Positionswerten,
um Sonnen und Mondstand graphisch anzuzeigen (Kreisbahn, stimmt zwar nicht genau,
ist aber am einfachsten umzusetzen und soll ja auch nur eine ungefähre Position angeben).

.. ach ja : bei Wikipedia gibt's auch einiges, teilweise mit Tutorial-Charakter.

... ja, und dann mal sehen, was mir noch so einfällt ...

p.s. schönen Gruß an meine Heimatstadt (Marzipan .... :-D

@markus5766h;

Danke für den Tipp,
werde ich mir gerne 'mal antun :)

[OT] Audio-Highend und Analogfilter gehören auch zu meinen Hobbies [/OT]

Gruß nach Hamburg

Wolfgang

Noch ein Tipp - definiere zuerst die Typen und dann lass die Konstanten folgen:

Delphi-Quellcode:

			type

  ...

  TEclipse=(ecNone, ecPartial, ecNoncentral, ecCircular, ecCirculartotal, ecTotal, ecHalfshadow);

...

const

 EclipseName : array [TEclipse] of string =  // vorher: array[0..6]

   ('', 'Teilfinsternis', 'Teilfinsternis', 'Randfinsternis',

    'Teilfinsternis mit Rand', 'Totale Finsternis', 'Halbschatten');

So kannst du die Deklaration für EclipseName verbessern.
Dies vereinfacht deinen Code und erhöht die Sicherheit weil der Compiler sicherstellt, dass die Anzahl der Strings genau auf den Typ TEclipse passt.
Das Gleiche gilt auch für "Bundesland", "Jahreszeit",...

Ausserdem würde ich empfehlen einen eigenen Datentyp für die Längen- und Breitenangaben zu deklarieren:

Delphi-Quellcode:

			type

TGeoAngle = Extended;

function Sun_Rise(date:TDateTime; latitude, longitude:TGeoAngle):TDateTime;

Damit wird der Code besser lesbar denn man sieht, dass die Funktion Sun_Rise() zwei Winkelangaben erwartet.

Der Code enthält EXTREM viele hartcodierte Zahlen; man kann das bei astronomischen Berechnungen nicht ganz vermeiden.
Manche Werte können aber leicht durch Konstanten ersetzt werden.
HOURS_PER_DAY=24; EARTH_DIAMETER=...; AVERAGE_MOON_DISTANCE=...
Mit den Konstanten versteht man besser was da eigentlich gerechnet wird.

@sx2008

danke für die Tipps, werd' ich bei der nächsten Bearbeitung umsetzen

Hallo,

Die Attachments wurden aktualisiert. Einige Vorschläge wurden umgesetzt.

neue Funktionen :

Delphi-Quellcode:

			function GetMoonPhaseNum(Age : extended):Integer;

function DateTimeReal(DtTm : TDateTime; Long : extended):TDateTime;

function DateTimeTZ(DtTm : TDateTime; Hour : ShortInt):TDateTime;

GetMoonPhaseNum liefert die Phase (1 .. 8) so dass Mondphasenbilder
entsprechend den Nummern angezeigt werden können (ist im Demo aktualisiert).
Die Verteilung ist :
1 : Neumond 1,00 Tage
2 : zunehmender Mond 4,5833 Tage
3 : zunehmender Halbmond, erstes Viertel 4,5833 Tage
4 : zunehmender Mond 4,5833 Tage
5 : Vollmond 1,00 Tage
6 : abnehmender Mond 4,5833 Tage
7 : abnehmender Mond, letztes Viertel 4,5833 Tage
8 : abnehmender Mond 4,5833 Tage

Die Verteilung und / oder Anzahl kann leicht in der entsprechenden Case - - Of - Anweisung geändert werden

DateTimeReal liefert den TDateTime-Wert an Hand des Längengrad
DateTimeTZ liefert den TDateTimeWert zur Zeitzone (der Vollständigkeit halber)

könntest du dementsprechend noch die Werte von 1 bis 8 als Konstanten definieren? SO wird der Code in der Case-Anweisung schneller ersichtlich.

Bernhard

@ Bernhard

o.k., werd' in der nächsten Version noch eine Funktion mit definierten Konstanten einfügen.
Die jetzige Funktion will ich so beibehalten, um diese eigenen Bedürfnissen anzupassen (z.B.
möchte jemand vielleicht 28 Bilder verarbeiten - statt 8, dann ist ein Integerwert sicher besser zu gebrauchen als 8 definierte Konstanten).

:?: :?: Es ging mir um die Lesbarkeit des Codes und ich und manch anderer auch findet halt, dass MOON_PHASE_NEW_MOON besser zu lesen ist als "1"

Bernhard

o.k., wie ist's damit :

Delphi-Quellcode:

			TMoonPhase8 = (mp_NewMoon, mp_WaxingMoonFirstEighth, mp_WaxingMoonFirstQuarter,  mp_WaxingMoonThirdEighth, mp_FullMoon, mp_WaningMoonFifthEighth, mp_WaningMoonLastQuarter, mpWaningMoonSevensEighth);
		

Funktion

Delphi-Quellcode:

function GetMoonPhaseConst(Age : extended):TMoonPhase8;

eingefügt

hier mal 'nen kleines Demo zur relativen Anzeige
von Mond- und Sonnen-Position

... soll nur als Beispiel dienen

falls Fragen auftauchen : nur zu.

anbei ausgegliederte Funktionen zur Berechnung von Ostern
als Funktion, Rückgabewert : TDateTime

1) Berechnung nach GAUSS für den gregorianischen Jalender
2) Berechnung nach GAUSS für den julianischen Kalender
3) Berechnung nach Lichtenberg (modifizierte Gauss-Formel)

Deine Unit Funktioniert auch noch einigen Änderungen Problemlos in Lazausr(Unter Linux).
Ich habe folgende Änderungen gemacht:
01: Die Unit Windows Entfernt
02: Die Funktionen "EDrive. DateTimeReal und DateTimeTZ" habe ich einfach auskommentiert. Sie scheinen in der Unit nicht verwendet zu werden.

Ich hoffe es macht nichts das die letzte Antwort älter als ein Halbes Jahr ist. Ich wollte auch nur drauf hinweisen, dass die Unit auch unter Lazarus läuft und ich sie wohl für mein Projekt verwenden werde.

Ein Verbesserungs Vorschlag:
Es wäre schön, wenn GetSternzeichen nicht nur ein Bereich prüfen könnte sondern auf Wunsch z.b. über ein Optimalen Parameter ob das Anfang Datum oder End Datum von einem Zeitraum gewünscht ist oder halt ein Zeitraum.
Ich hoffe du weißt was ich damit meine.

Jedenfalls gefällt mir die Unit recht gut, wobei ich auch Ähnlichkeiten zu einer anderen Unit bemerkt habe... Aber bestimmt ist das reiner Zufall:

http://www.delphi-fundgrube.de/files/feiertg.txt oder?
(...Ich habe mir jetzt nicht den ganzen Thread durchgelesen...)

Zitat:

Zitat von mimi (Beitrag 1082973)

Ich habe folgende Änderungen gemacht:
01: Die Unit Windows Entfernt
02: Die Funktionen "EDrive. DateTimeReal und DateTimeTZ" habe ich einfach auskommentiert. Sie scheinen in der Unit nicht verwendet zu werden

diese Funktionen sind später hinzugekommen :
DateTimeReal liefert die (theoretische) Zeit (und Datum) auf Grund der Position,
DateTimeTZ liefert Datum/Zeit unter Angabe der Zeitzone
. . . ach ja, und EDrive war (bzw. ist) eine Hilfs-Funktion zur quantitativen
Darstellung der Mondposition in Abhängigkeit von Datum/Zeit (auf einer Kreisbahn,
nicht auf einer Ellipse) - ist also für diese Unit nicht nötig.

Zitat:

Zitat von mimi (Beitrag 1082973)

1)Ein Verbesserungs Vorschlag:
Es wäre schön, wenn GetSternzeichen nicht nur ein Bereich prüfen könnte sondern auf Wunsch z.b. über ein Optimalen Parameter ob das Anfang Datum oder End Datum von einem Zeitraum gewünscht ist oder halt ein Zeitraum.
Ich hoffe du weißt was ich damit meine.

2)Jedenfalls gefällt mir die Unit recht gut, wobei ich auch Ähnlichkeiten zu einer anderen Unit bemerkt habe... Aber bestimmt ist das reiner Zufall:

http://www.delphi-fundgrube.de/files/feiertg.txt oder?
(...Ich habe mir jetzt nicht den ganzen Thread durchgelesen...)

ad 1) werd' ich mir mal auf die Liste schreiben (kann allerdings etwas dauern)
ad 2) kannte ich noch nicht, allerdings sind ähnliche Funktionen in einigen Büchern
beschrieben, so dass diese nicht sehr voneinander abweichen können

Hallo.

--> 21.12.2013 : Version 4 angefügt (Astro4.rar) :
hinzugekommen sind Berechnungen zum "Blue Moon":
function BlueMoon . . . - hier wird auf vier Vollmonde in einer Jahreszeit geprüft, der
dritte Vollmond ist dann der Blue Moon.
Im Aufruf der Funktion kann dann noch festgelegt werden, ob der
vergangene Winter oder der kommende Winter berücksichtigt wird,
geprüft wird über vier Jahreszeiten.
function Double Moon . . . - hier wird auf zwei Vollmonde in einem Monat geprüft, je nach
Definition (es gibt mehrere) ist dann der zweite Vollmond
(30. od. 31. eines Monats) der Blue Moon.

-- in Kürze : Auswahl der Berechnungen zu Sonnenstand, Auf-Untergang nach
realer (-0,83333°), bürgerlicher(-6°), nautischer(-12°), astronomischer(-18°) Dämmerung
--> erledigt (siehe Post #1)

ein frohes Weihnachtsfest und einen guten Rutsch in's neue Jahr :xmas::party:

Hallo,

in der Astro4.rar --> uAstro.pas war noch ein kleiner Fehler versteckt :

Delphi-Quellcode:

			function NextEclipse(var Date : TDateTime; sun : Boolean): TEclipse;

var

  temp_date: TDateTime;

begin

  Result := ecNone;

  temp_date := Date - 28 * 2;

  while temp_date < Date do

   begin

    temp_date := temp_date + 28;

    Result := Eclipse(temp_date, sun);

   end;

  date := temp_date; // <----- diese Zeile muss entfernt werden !!!!!!!!!!!

end;

im Post #1 ist die Datei aktualisiert !

Ein Demo basierend auf dem Archiv "Astro4.rar" ist angefügt.

zur Beachtung :
vor Abfragen des HolidayIndex (function GetHolidayIndex(Date : TDateTime; Land : TdeState): Integer;)
muss die Funktion (function GetSeason(Date : TDate): String; ) aufgerunfen werden,
da in der Funktion HolidayIndex Werte verwendet werden, die in der Funktion GetSeason erzeugt werden.

In der Demo werden nur Werte in der Schriftfarbe 'schwarz' aktualisiert.

Ich weiß das das Thema alt ist, aber ich wollte jetzt auch nicht extra ein neuen Thread dazu aufmachen.

Ich nutze inzwischen die neue Unit unter Lazarus.

Bei der neuen, wie bei der alten, gibt es bei Sun_Rise Abweichungen.
Heute z.b. sollte laut Refernezn Quellen im Internet die Sonne um 07:04 Uhr aufgehen, aber laut Unit um 05:34. Rechnet man 1 Stunde und 30 Minuten hinzu passt es wieder.
Wie kommt es zu dieser "Abweichung"?

Code:

			procedure TForm1.BitBtn1Click(Sender: TObject);

begin

  writeln('ctAstronomical: ',DateTimeToStr(Sun_Rise(Now,+53.143889,+8.213889,ctAstronomical)));

  writeln('ctNautic: ',DateTimeToStr(Sun_Rise(Now,+53.143889,+8.213889,ctNautic)));

  writeln('ctZivil: ',DateTimeToStr(Sun_Rise(Now,+53.143889,+8.213889,ctZivil)));

  writeln('ctGeneral: ',DateTimeToStr(Sun_Rise(Now,+53.143889,+8.213889,ctGeneral)));

  writeln('ctNull: ',DateTimeToStr(Sun_Rise(Now,+53.143889,+8.213889,ctNull)));

end;

Ich habe die Position für Oldenburg(Oldenburg) Angegeben.
Oder mache ich noch was Falsch?

Ich tippe auf
1. eine Stunde weil wir aktuell Sommerzeit haben. Winterzeit wäre der Sonnenaufgang schon um 6:04
2. eine halbe Stunde, weil Oldenburg nicht in der Mitte der Zeitzone liegt. Die Astro-Zeit ist dann die "tatsächliche, lokale" Zeit, Oldenburg liegt mit 8° schon weit von der Mitte (15°) entfernt.

Währe auf jedenfall eine Erklärung.

Wie könnte man das "Ausgleichen"? Sommerzeit/Winterzeit könnte man ja noch hinzurechnen das wäre nicht das Problem, aber die Halbestunde. Müsste ich jetzt die angeben koordinaten weiter anpassen?

Ach ja: Ich kann auch die Werte aus der uTable unit nehmen, dass ist das gleiche...

Du müsstest wissen, welche Zeitzone dort herrscht, das ist schon mal ein Thema für sich. In diesem Fall MESZ, also UTC+2.

Für jede Stunde UTC+ rechnest du 15° vom Nullmeridian, dann bist du bei +30°. Die Differenz aus diesem Wert und deiner östlichen Länge (8,213889) ergibt 21,786111°. Oder in Stunden ausgedrückt (1h = 15°) sind das 1,4524074 Stunden. Kann das hinkommen?

Zitat:

Oder in Stunden ausgedrückt (1h = 15°) sind das 1,4524074 Stunden. Kann das hinkommen?

Noch nicht so ganz: So müsste es laut Referenz sein:
2015-01-01 08:41:19
Das kommt von einer Perl Lib.
Aber so ist es laut Astro Unit
2015-01-01 08:59:10
Es sind also fast 20 Minuten zu viel.
Aber wir nähern uns.

Delphi-Quellcode:

			procedure TForm1.BitBtn1Click(Sender: TObject);

var

  SunRise,SunSet,DT:TDateTime;

  YY, MM, DD, H, M, S, MS:Word;

  I1,I2, DM:integer;

  D:TDate;

begin

  InitLocale; // Muss das gemacht werden? Ändert jedenfalls nichts.

  for I1:=1 to 12 do begin

    DM:=DaysInAMonth(2015,I1);

    for I2:=1 to DM do begin

      D:=EncodeDate(2015,I1,i2);

      SunRise:=Sun_Rise(D,+53.143889,+21.786111,ctZivil); // 8.213889

      Memo1.Lines.Add(DateTimeToStr(SunRise));

    end;

  end;

end;

Neue info:
Wenn ich von ctZivil auf ctGeneral umstelle klappt es. Dann gibt es kaum noch Abweichungen. Dann muss ich im Winter nur noch 1 Stunde abziehen.
Wenn ich jedoch ctAstronomical meint die Unit, dass die Werte nicht errechenbar sind. Ab 2015-05-15.

Delphi-Quellcode:

			procedure TForm1.BitBtn1Click(Sender: TObject);

var

  SunRise,SunSet,DT:TDateTime;

  YY, MM, DD, H, M, S, MS:Word;

  I1,I2, DM:integer;

  D:TDate;

begin

  InitLocale;

  for I1:=1 to 12 do begin

    DM:=DaysInAMonth(2015,I1);

    for I2:=1 to DM do begin

      D:=EncodeDate(2015,I1,i2);

      SunRise:=Sun_Rise(D,+53.143889,+21.786111,ctGeneral); // 8.213889 //21.786111

      Memo1.Lines.Add(DateTimeToStr(SunRise));

    end;

  end;

end;

Nun gibt es nur noch eine Sekunde Abweichung.

Edit1: Im Sommer sind die Abweichungen größer. Aber noch im Sekunden Bereich.

Ich habe noch ein paar Fragen zur Unit:
1. Warum ist das bei dieser Unit, anders beim Sonnenaufgang/Untergang als es andere machen?
Z.b. habe ich ein Code für Arduino gefunden, der macht es so, wie ich es erwarte und wie es alle anderen machen(Die Berechneten Zeiten stimmen mit den von verschiedenen Wetter-Diesten überein).
Außerdem habe ich noch ein Perl Skript gefunden, die es auch genau so machen.

2. Könnte man es die Übergabe der Koordinaten vereinfachen?
Wenn es wirklich der Mittelpunkt der Zeitzone sein muss.

3. Könnte man in der Unit am Anfang darauf hinweisen? Auf diese Abweichungen?

Ich finde die Unit nicht schlecht und bin schon froh das sie unter FPC läuft. Kann das der Grund für die Abweichung sein?

... ist zwar schon etwas her, aber . . .

zum Sonnenaufgang - habe heute mal im Netz die Werte für den Sonnenaufgang für Hamburg aufgerufen (Wetterdienste und andere),
Ergebnis : 10 verschiedene Zeiten in einem Zeitraum von 30 Minuten (ohne Angabe der Bezugsposition) - und genau hier liegt das Problem : ohne die Berechnungsparameter zu kennen, ist ein Vergleich nicht möglich, einige werden wohl für die exacte geogr. Position berechnen, andere für gerundete Positionswerte oder die "Mitte" der Zeitzone . . .

Was ist mit der Sternzeit? Könnte JamesTKirk Interessieren...:stupid:

Hast Du auch etwas um die Position der Planeten im Sonnensystem mit den Monden darzustellen?

Sorry, wenn ich mich hier jetzt kurz einmische bezüglich der berechneten Zeiten.

Ich habe die Unit nicht getestet, habe aber vor einigen Jahren auch mal mit den Algorithmen von Jean Meeuse (Buch: Astronomische Algorithmen, 1994) zu tun gehabt.

Die Internationale Astronomische Union (IAU) hat festgelegt, daß das Längengradsystem eines Planeten immer positiv entgegen der Planetenrotation gezählt wird. Bei der Erde ist das der einzige Planet bei dem das anders herum ist (historische Gründe; man fing an Längengrade zu nutzen, bevor man über allgemeine Sachen nachdachte). Nun war Meeus aber sehr stark im IAU System verhaftet und hat seine Algorithmen entsprechend allgemein aufgebaut.

Mich hat es damals einiges an Zeit gekostet, die Abweichungen wirklich zu verstehen. Der Fehler lag bei mir einfach darin, daß man positiv/negativ im Längengrad umkehren musste. Hast du entsprechend mal etwa -8 (minus 8 Grad) für Oldenburg probiert an Stelle der offiziellen Zählung von +8 ???

Da wir nahe am vereinbarten Nullmeridian leben, ist man schnell versucht, solche verhältnismäßig geringen Abweichungen 'schönzuerklären'. Ein Versatz von 1.5 Stunden könnte hier durchaus im Rahmen dieser plus/minus Geschichte liegen.

Deutlicher wird der Fehler, wenn man Orte mit größeren longitudinalen Werten berechnet (Moskau, Delhi, Sydney, Washington, San Francisco, ...)

Ist nur so eine Idee....

Insgesamt ist es aber natürlich auch so, das meist die Mitten der Zeitzonen angegeben werden (der Breitengrad hat natürlich zusätzlich auch einen Einfluss). Das schöne an den Algos von Meeus ist aber, das man die realen, ortsbezogenen Daten relativ gut berechnen kann... und die weichen immer etwas von offiziell tabulierten Werten ab...

Einige Minuten Abweichung ergeben sich teils auch schon aus unterschiedlichen Algorithmen, die unterschiedliche Näherungen produzieren. Aber sind wir mal ehrlich: ob die Sonne um 06:30 oder um 06:32 aufgeht ist eher irrelevant für die meisten irdischen Anwendungen. Spätestens wenn eine Wolke am Himmel ist, kann ich daraus wenig allgemeine Lichtverhältnisse ableiten...

Das schwer erhältliche Buch von Meeus (Scan, 72.1 MB) darf ich aus copyright Gründen natürlich auf gar keinen Fall an jemanden weiterreichen, der zu mir per PN Kontakt aufnimmt...

Jan

Zitat:

Zitat von Mavarik (Beitrag 1345821)

Hast Du auch etwas um die Position der Planeten im Sonnensystem mit den Monden darzustellen?

... derzeit (leider) nicht.

Zitat:

Zitat von BoolString (Beitrag 1346123)

... Das schwer erhältliche Buch von Meeus (Scan, 72.1 MB) darf ich aus copyright Gründen natürlich auf gar keinen Fall an jemanden weiterreichen, der zu mir per PN Kontakt aufnimmt...
Jan

... taucht ab und zu bei Amazon auf, so um die 45€

Zitat:

Zitat von markus5766h (Beitrag 985553)

Hallo,
im Laufe der Zeit haben sich bei mir einige Funktionen zur Berechnung astronomischer Daten gesammelt, die ich nun in eine Unit gepackt habe :
// Datum zweiter Vollmond in einem Monat
[/DELPHI]

Hallo Markus,

erstmal super Dankeschön für die Unit. :thumb: :thumb: Ich lerne im Moment Delphi. Eine kleine Frage:
Kann ich das Demo-Projekt als Source haben?

Vielen Lieben Dank. :stupid::cyclops:

Andy