Berechnung der Rektaszension und Deklination eines Sterns

[Fohnbit]

Hallo,

ich habe mit Hilfe eines Astroforum Teilnehmer eine Methode zum Berechnen von Azimuth und Höhe, wenn die Rektaszension und Deklination eines Sterns gegeben sind.
Ich habe das mit Stellarium gegen geprüft und scheint alles zu stimmen.

Ich benötige aber die andere Richtung. Berechnung der Rektaszension und Deklination, wenn der Azimut und Höhe gegeben sind.

Kennt da jemand eine Library? Den gegebenen Code umschreiben gelingt mir nicht. Dazu bin ich zu wenig Mathematiker :-(

Also privater kleiner Sternefotograf möchte ich von einem Neigungssensor die Winkelinformation in Rekt und Dekl ausgeben lassen, damit ich leichter "anzielen" kann 🙂

Für Eure Hilfe wäre ich sehr dankbar!

 

[Fohnbit]

anbei noch die Berechnung die ich soweit fertig habe:

public class PositionCalculator {

    static final double LATITUDE = 47;
    static final double LONGITUDE = 15;

    static final LocalDateTime OBJECT_DATE_TIME = LocalDateTime.of(2020, Month.APRIL, 11, 22, 00, 00);

    public static void main(String[] args) {
        new PositionCalculator("Beteigeuze", "5h56m17.41s", "7°24'33.3''");
        new PositionCalculator("Sirius", "6h46m03.40s", "-16°44'45.7''");
        new PositionCalculator("Regulus", "10h09m28.14s", "11°51'57.0''");
        new PositionCalculator("Aldebaran", "4h37m06.45s", "16°32'56.8''");
        new PositionCalculator("Capella", "5h18m13.17s", "46°01'00.0''");
        new PositionCalculator("Vega", "18h37m38.10s", "38°48'15.3''");
        new PositionCalculator("Spica", "13h26m17.00s", "-11°16'06.5''");
        new PositionCalculator("Alphard", "9h28m36.10s", "-8°44'56.3''");
        new PositionCalculator("West 1", "4h51m44.33s", "8°56'02.3''");
        new PositionCalculator("West 2", "4h50m57.74s", "6°59'44.5''");
        new PositionCalculator("Denebola", "11h50m06.68s", "14°27'23.7''");
        new PositionCalculator("Test 1", "10h33m53.80s", "9°11'59.2''");

    }

    public PositionCalculator(String name, String object_Rekt, String object_Dekl) {

        double raHour = Double.valueOf(object_Rekt.split("h")[0]);
        double raMinute = Double.valueOf(object_Rekt.split("h")[1].split("m")[0]);
        double raSecond = Double.valueOf(object_Rekt.split("h")[1].split("m")[1].split("s")[0]);
        raMinute += raSecond / 60;

        double rightAscensionInDegrees = raHour * 15 + raMinute / 4;

        double dekDegree = Double.valueOf(object_Dekl.split("°")[0]);
        double dekMinute = Double.valueOf(object_Dekl.split("°")[1].split("'")[0]);
        double dekSecond = Double.valueOf(object_Dekl.split("°")[1].split("'")[1].split("''")[0]);
        dekMinute += dekSecond / 60;

        if (dekDegree < 0) {
            dekDegree = (dekDegree * -1 + dekMinute / 60) * -1;

        } else {
            dekDegree = dekDegree + dekMinute / 60;
        }

        ZonedDateTime localDateTimeAtZone = OBJECT_DATE_TIME.atZone(ZoneId.of("Europe/Berlin"));
        ZonedDateTime localDateTimeAtInUTC = ZonedDateTime.ofInstant(localDateTimeAtZone.toInstant(), ZoneOffset.UTC);

        SiderealTimeCalculator siderealTimeCalculator = new SiderealTimeCalculator(localDateTimeAtInUTC);

        double hourAngle = siderealTimeCalculator.getSiderealTimeAsDegree() - rightAscensionInDegrees;

        double sinOfa = Math.sin(Math.toRadians(LATITUDE)) * Math.sin(Math.toRadians(dekDegree))
                + Math.cos(Math.toRadians(LATITUDE)) * Math.cos(Math.toRadians(dekDegree))
                        * Math.cos(Math.toRadians(hourAngle));
        double altitude = Math.toDegrees(Math.asin(sinOfa));

        double tanAzimuth = Math.sin(Math.toRadians(hourAngle))
                / ((Math.cos(Math.toRadians(hourAngle)) * Math.sin(Math.toRadians(LATITUDE)))
                        - (Math.tan(Math.toRadians(dekDegree)) * Math.cos(Math.toRadians(LATITUDE))));

        double azimuth = Math.toDegrees(Math.atan(tanAzimuth));
        azimuth = (azimuth + 360) % 360;

        if (raHour < 12 && azimuth > 0 && azimuth < 90) {
            azimuth += 180;
        } else if (raHour > 8 && raHour < 18 && azimuth > 270 && azimuth < 360) {
            azimuth -= 180;
        }
        //System.out.println(azimuth);
        System.out.println("Name\t" + name);
        System.out.println("RA\t" + object_Rekt + "\tAzimuth\t" + azimuth);
        System.out.println("Dek\t" + object_Dekl + "\tHöhe\t" + altitude);
        System.out.println("");
    }
}

und die SiderealTimeCalculator Klasse:

public class SiderealTimeCalculator {

    private double siderealTimeHours;
    private double siderealTimeMinutes;
    private double siderealTimeSeconds;

    public SiderealTimeCalculator(ZonedDateTime localDateTimeInUTC) {
        calculateSiderealTime(localDateTimeInUTC);
    }

    private void calculateSiderealTime(ZonedDateTime localDateTimeInUTC) {

        double julianDate = calculateJulianDate(localDateTimeInUTC);

        double t = (julianDate - 2451545.0) / 36525;
        double GMST_ZERO = 24110.54841 + (8640184.812866 * t) + (0.093104 * (t * t)) - (0.0000062 * (t * t * t));

        GMST_ZERO += 1.00273790935 * (localDateTimeInUTC.getHour() * 3600 + localDateTimeInUTC.getMinute() * 60
                + localDateTimeInUTC.getSecond());

        double LMST = GMST_ZERO + (PositionCalculator.LONGITUDE / 15) * 3600;

        siderealTimeHours = (LMST / 3600) % 24;
        siderealTimeMinutes = (siderealTimeHours - ((int) siderealTimeHours)) * 60;
        siderealTimeSeconds = (siderealTimeMinutes - (int) siderealTimeMinutes) * 60;

    }

    public static double calculateJulianDate(ZonedDateTime utcDateTime) {
        int month = utcDateTime.getMonth().getValue();
        int year = utcDateTime.getYear();
        int day = utcDateTime.getDayOfMonth();

        double jd = 2415020.5 - 64;
        if (month <= 2) {
            year--;
            month += 12;
        }
        jd += (int) ((year - 1900) * 365.25);
        jd += (int) (30.6001 * (1 + month));
        return (jd + day);
    }

    public int getSiderealTimeHours() {
        return (int) siderealTimeHours;
    }

    public int getSiderealTimeMinutes() {
        return (int) siderealTimeMinutes;
    }

    public int getSiderealTimeSeconds() {
        return (int) siderealTimeSeconds;
    }

    public double getSiderealTimeAsDegree() {
        return getSiderealTimeHours() * 15 + (getSiderealTimeMinutes() / 4.0) + (getSiderealTimeSeconds() / 240.0);
    }

}

 

[Xyz1]

Ich bin zwar auch kein Physiker, aber ich verstehe nur Bahnhof. 😀 Kannst du vielleicht einmal in Prosa beschreiben was du machen möchtest? Also: Ich habe ein Fernglas/Teleskop und möchte den Andromeda-Nebel M31 beobachten. Wie muss ich dafür das Teleskop einstellen? Der Andromeda-Nebel hat dabei folgende Eigenschaften: ... usw.

 

[Fohnbit]

Also 🙂

ich habe ein Teleskop, das den Bahnen der Sterne folgt ... das macht das System selbst und passt.

Aber wenn ich als Beispiel M31 fotografieren möchte, muss ich das mal finden und in den Sucher der Kamera bekommen 🙂 Nun, M31 sieht man ja fast mit freiem Auge, aber die kleinen ... da braucht man ein paar Testschüsse bis es passt.

Ich möchte mir nun einen Neigungssensor montieren, welcher mir den Winkel der montierten Kamera zurückgibt. Ausgehend von meiner Position und Zeit kann ich dann sagen, wohin im Sternenatlas die Kamera schaut.

(1) Die Sterne werden mit dem Äquatoriales Koordinatensystem angegeben: Rektaszion und Deklination
Diese Position ist von jedem Punkt auf der Erde gleich (Zum selben Zeitpunkt)

(2) Wenn ich aber auf der Erde stehe und den Stern anschaue, habe ich von meiner Position aus Azimuth (Himmelsrichtung) und Höhe (Winkel vom Äquator) zum Stern

Wenn ich also einen Stern aussuche, der auf (1) liegt, kann ich meinen Code oben nehmen und weiß Himmelsrichtung und Höhe von meinem gegenwärtigen Standpunkt. Beispiel 180° (Süden) und 57,5° hoch.

Aber durch den neuen Neigungswinkel Sensor, habe ich (2) eine Höhe und Richtung und müsste wissen, wohin ich schau, im Äquatoriales Koordinatensystem System.

Also wenn der Sensor anzeigt:
Azimuth: 180°
Höhe: 57,5°

So drehe ich solange die Anlage, bis ich die gewünscht (1) Position erreicht habe und dann sollte der Stern in meinem Sucher sein 🙂

Ich gebe dann eben nicht Azimut und Höhe aus, sondern rechne auf Rektaszion und Deklination um.

Denn wenn ich M31 fotografieren möchte, weiß ich er liegt auf:
Rekt: 0h43m35s
Dekl: 41°20m5s

Dann drehe ich die Anlage so lange, bis ich diese Werte angezeigt bekomme. Aber dafür muss ich Azimuth und Winkel zu Rest und Dekl umrechnen

Danke!

 

[Fohnbit]

Man müsste also meine Berechnung oben zurück rechnen.Von Azimut und Höhe zur Rektaszension und Deklination, aber dafür sind meine Mathe Kenntnisse zu gering :-(

 

[AndiE]

Vielleicht hilft das weiter:
am 21.3. , dem Frühlingspunkt, schaue ich um 12 Uhr in die gleiche Richtung wie
am 21.6. um 18 Uhr
am 21.9. um 0 Uhr und
am 21.12. um 6 Uhr

am 21.3. und am 21.9. liegt mein Zenit bei 54 °
das ändert sich am 21.12. zu 54-23,5=30,5° und
am 21.6, zu 54+23,5=67,5°
und das zu dem Zeitpunkt, in dem ich zur Sonne schaue.

Nach obiger Berechnung verschiebt sich dieser "Mittagspunkt" täglich um 1/365. Das heißt, wenn es 12 Uhr ist, schaue ich immer zur Sonne.

Die Frage, ob ich nach Azimut und Winkel den Ort bestimmen kann, ist ja erstmal, wie ich das bestimme. Sicher am einfachsten ist es, diese in Winkel zu Nord( Osten sind 90° etc) zu bestimmen und die Höhe über dem Horizont in Grad.

Könnte man jetzt sagen, dass ein Stern, den ich am 21.9. am 0 Uhr am Horizont in Nordrichtung gesehen habe, am 21. 3. um 12 Uhr in Richtung Süd am Horizont steht? Dann kann ich ihn aber nicht sehen, da ja Tag ist.

 

[mihe7]

Ekliptik, Frühlingspunkt, Stern-Stunde... Was gibt's zu essen?

 

[Xyz1]

Moin mihe 😉