nathan frad

HELP : éphémérides des planètes

Messages recommandés

Bonjour,

 

Nous sommes trois étudiants qui sommes à la recherche d’aide dans le domaine de l’astronomie. Je m’explique : Depuis la rentrée 2017 nous travaillons dans une boite d’informatique en contrat de professionnalisation, afin d’avoir un diplôme de concepteur développeur informatique. Dans le cadre de ses études nous devons réaliser un projet sur deux ans. Celui-ci consiste à diriger un télescope Celestron via une raquette Nexstar. Lors de nos recherches nous nous sommes rendu compte qu’il fallait calculer les éphémérides des planètes, cependant nous n’avons pas les connaissances nécessaires dans ce domaine. C’est pourquoi nous sommes à la recherche de personnes qui souhaiteraient partager son savoir bénévolement. La difficultés que nous rencontrons est de comprendre le calcul des positions des planètes... Merci d'avance pour vos multiples réponses. :)

Partager ce message


Lien à poster
Partager sur d’autres sites

Il suffit pas d'écrire "Vénus" ou "Uranus" sur la raquette pour que le télescope pointe automatiquement ? Ca m'étonne énormément... 

S

Partager ce message


Lien à poster
Partager sur d’autres sites

Nous pensions aussi, au début, pouvoir utiliser la basse de donnes de la raquette en envoyant une commande externe ( ex : "venus") mais ce n'est pas le cas. Nous pouvons envoyer que des commandes en hexadécimale ( ra/dec converti en hexadecimal ).

Partager ce message


Lien à poster
Partager sur d’autres sites

Les équations de Kepler doivent fournir une bonne précision pour prévoir les position sur plusieurs dizaines d'années et sans doute plus. 

La partie un peu plus difficile, c'est de tenir compte du point de vue de la Terre et convertir ça en RAD et DEC. 
Sinon la solution de fainéant c'est d'aller interroger un autre outil qui fait le calcul lui même. Le site de l'IMCCE, le JPL ou n'importe quel logiciel de cartographie du ciel.

En même temps, ce que vous cherchez à faire existe déjà, les logiciels capables de piloter un télescope de ce type et de calculer la position des planètes sont nombreux. Certains doivent être plus ou moins open source, peut être que leur code est accessible. Je pense à Carte du Ciel et Stellarium.  

Partager ce message


Lien à poster
Partager sur d’autres sites

merci de votre réponse. Cependant nous savions déjà cela mais nous voulons l’adapter a un système embarquer! C'est pour cela que nous avons besoin du code en "dur" . Nous avons déjà examiner les logiciels que vous avez cité mais sans aboutissement. Nous souhaitons juste le calcul mathématique , même si il est très complexe. C'est pour cela que nous souhaitons un partage de connaissance dans ce domaine. Nous sommes de plus très curieux dans ce domaine.  ;)

Partager ce message


Lien à poster
Partager sur d’autres sites
Posté(e) (modifié)

Ces logiciels sont une propriété intellectuel,  leur décodage ou détournement de leur utilisation sans autorisation préalable peut être considéré comme du piratage. 

Modifié par capt flam

Partager ce message


Lien à poster
Partager sur d’autres sites
Posté(e) (modifié)

Pour savoir comment calculer la position des planètes, il y a des bouquins comme celui de J. Meeus, dont l'édition en anglais peut être commandée chez Wilmann-Bell : http://www.willbell.com/math/mc1.htm  . Je crois qu'il y a aussi des sites Internet qui expliquent ça, mais le livre de Meeus me semble indispensable car complet et détaillé (il ne s'agit pas que de programmer des algorithmes tout fait, il faut aussi les comprendre).

 

Sur le même site, on trouve ce livre : http://www.willbell.com/math/fundephcomp.htm . Je ne sais pas ce qu'il vaut, mais il est livré avec les sources en Basic et en C, au cas où...

 

Modifié par Bruno-
  • J'aime 1

Partager ce message


Lien à poster
Partager sur d’autres sites
Il y a 15 heures, capt flam a dit :

Ces logiciels sont une propriété intellectuel,  leur décodage ou détournement de leur utilisation sans autorisation préalable peut être considéré comme du piratage. 

Bonjour, 

 

Si les logiciels sont libre de droit ce n'est en aucun cas du piratage.

Partager ce message


Lien à poster
Partager sur d’autres sites
Le 09/10/2017 à 19:32, Yves BACHELET a dit :

Il y a le livre de Jean Meeus qui explique comment calculer les positions des planètes :

https://www.maison-astronomie.com/calculs/2950-calculs-astronomiques-a-l-usage-des-amateurs.html

 

A mon avis, on peut le trouver dans toutes les bibliothèques universitaires ou des grandes écoles. Ça peut être ardu comme calcul !

 

Merci, sur vos conseils nous avons commandé ce livre.

 

Le 09/10/2017 à 21:42, bricodob300 a dit :

Salut Nathan et bienvenue.

Si tu veux pas te cogner les qques milliers de terme des formules : http://neoprogrammics.com/vsop87/

tu choisis les astres, le référentiel, les coordonnées et le langage  et voilou.

JP

 

 

Ce lien est très intéressant. Nous allons nous penché sur le sujet et nous vous tenons au courant. Merci beaucoup.

Tout vos messages sont très important pour l'avancer de notre projet.

Partager ce message


Lien à poster
Partager sur d’autres sites

Bonjour, je reviens vers vous pour plus ample information.
Je viens de tester le code généré par vsop87 ( http://neoprogrammics.com/vsop87/) qui me renvoie soit :
       L = Longitude in radians
       B = Latitude in radians
       R = Radius vector in AU (Astronomical Units)

( qui sont les coordonnées écliptiques si j'ai bien compris )

soit  x, y , z . ( HELIOCENTRIC DYNAMICAL ECLIPTIC AND EQUINOX OF THE DATE  Rectangular (X,Y,Z) Coordinates in AU (Astronomical Units)

Toutes ces informations renvoyé par le programme sont correct, j'ai vérifié avec des logiciels de calcul des éphéméride en ligne.

 

Cependant nous devons envoyé au télescope les donnes sous forme RA DEC ( coordonnées équatoriales). J'ai cherché comment convertir les coordonnées écliptiques vers les coordonnées équatoriales . J'ai trouvé ce calcul :

( https://fr.wikipedia.org/wiki/Système_de_coordonnées_célestes#Des_coordonn.C3.A9es_horizontales_aux_coordonn.C3.A9es_horaires)

3ffa24d1f3f58aa66a4874b1b2d12b271da49ab6

 

ce qui me donne ce calcul  ( j'ai essayé juste pour DEC pour l'instant mais  le résultat n'est pas bon comparé au résultat donné par les logiciels de calcul des éphémérides en ligne )  :

     
        dec = (Math.sin(23.439281)* Math.sin(longitude)* Math.cos(latitude)+ (Math.cos(23.439281)* Math.sin(latitude);

 

exemple pour le 1 janvier 2000 a 12 h 00 .00 :


        dec = (Math.sin(23.439281)* Math.sin(4.4293481036110025)* Math.cos(-0.05275734092008231)+ (Math.cos(23.439281)* Math.sin(-0.05275734092008231);

dec = 0.9581220776863877
 dec2 =Math.asin(dec) 1.2803706926523695

Mais devrais donné :   1.711989  selon le site de la nasa ( https://heasarc.gsfc.nasa.gov/cgi-bin/Tools/convcoord/convcoord.pl?CoordVal=4.4293481036110025+%2C+-0.05275734092008231&CoordType=Ecliptic&Resolver=GRB%2FSIMBAD%2BSesame%2FNED&NoCache=on&Epoch=2000 )

 

Si vous avez une idée pour que je trouve les coordonnées équatorial des planètes, je vous en serait très reconnaissant. Merci d'avance :D

 

Modifié par nathan frad

Partager ce message


Lien à poster
Partager sur d’autres sites

Bonjour ! J'ai refait le calcul en réglant ma calculatrice sur "radians" et je trouve exactement la même chose que toi. Ça signifie que tu as utilisé des longitudes et des latitudes en radians. Du coup, l'erreur est évidente... du moins une fois qu'on la vue : tu as utilisé ε en degrés !

 

Avec ε=0,4090926 rad, ça donne δ = -0,444271 rad = -25,45485°. Tiens, il y a donc une autre erreur.

 

(Remarque : ce que tu notes 'dec', tu devrais le noter 'sin_dec' puisque c'est le sinus de la déclinaison.)

 

D'ailleurs c'est pas compliqué à vérifier. Les valeurs en degrés sont environ λ = 253,793° et β = -3,023° : on est à 3° sous l'écliptique, qui est ici pas loin de sa déclinaison minimale (atteinte en 270°). Donc oui, ça doit faire une déclinaison d'environ -25°. Bref : je pense que l'autre erreur est que la bonne réponse n'est pas 1.71198. Voyons sur le lien de la NASA... OK, j'ai compris ! Sur le lien de la NASA, les coordonnées écliptiques que tu lui donnes sont 4.4293481036110025 , -0.05275734092008231. Or il attend des coordonnées en degrés ! Il faut lui fournir 253.7829523 et -3.022772973. On obtient alors δ = -25.454862, ça colle (la petite différence peut être due au fait que ε varie légèrement dans le temps).

 

Bref : attention aux unités ! (Je frime un peu, mais je me suis souvent fait piéger de même... c'est pour ça que j'y pense toujours à présent. :) )

Modifié par Bruno-
  • Merci 1

Partager ce message


Lien à poster
Partager sur d’autres sites

Merci beaucoup Bruno ! J'ai réussi a calculer la déclinaison (DEC) avec votre aide  mais maintenant je n’obtient  pas le bon RA ( Right acccension ) .... voici mon calcul ci-dessous ... je pense avoir fait attention aux unités pourtant...

 

// calcul RA en utilisant la deuxième équation  ***************************************************


        cos_ra = (Math.cos(longitude)* Math.cos(latitude)/ Math.cos(dec_rad);

        cos_ra = (Math.cos(4.4293481036110025)* Math.cos(-0.05275734092008231)/ Math.cos(-0.444270950257026);

         cos_ra = -0.30887225220868564

        ra_rad = Math.acos(cos_ra);

        ra_rad = Math.acos(-0.30887225220868564);

         ra_rad = 1.8848034049959312
              
        ra_deg = ra_rad*180/Math.PI;

       ra_deg = 1.8848034049959312 *180/Math.PI;

      ra_deg = 107.99128031815367
     

Ce qui donne 107 alors que ça devrais donner 252 ..... ( source de 252 : nasa )

 

 

Partager ce message


Lien à poster
Partager sur d’autres sites

Rhaaa, tu es tombé dans le piège classique ! (Je t'avouerais que je m'y attendais un peu : quand j'ai vu que tu avais calculé seulement la déclinaison, je me suis dit : pourvu qu'il ne tombe pas dans le piège quand il calculera l'ascension droite...)

 

Pour trouver α, il ne suffit pas de calculer le cosinus, car le même cosinus convient à deux angles : à 108° (quand tu trouves 107,99 tu dis que ça fait 107 ? tu as une drôle de façon d'arrondir...) mais aussi à -108°. En effet : cos( α ) = cos(- α ). Et figure-toi que -108°, c'est pareil que 252° (-108° + 360° = 252°).

 

C'est pour ça qu'on donne les deux formules : l'une pour le cosinus, l'autre pour le sinus. En fait le bon algorithme est le suivant :

 

1. Calculer X et Y :

X = cos λ cos β

Y = cos ε sin λ cos β - sin ε sin β

 

2. Puis on utilise la fonction du langage de programmation qui, à partir des coordonnées (X, Y), fournit l'angle polaire entre 0 et 2π (ou entre -π et π). Par exemple en langage C on utilise la fonction 'atan2'

 

ra_rad = atan2(Y, X) // dans cet ordre ! Et ça rend un résultat entre -π et π

 

Un autre algorithme possible est d'utiliser la fonction arc tangente de base, mais il y a deux cas à examiner :

Si X > 0 alors α = arctan (Y/X) sinon si X < 0 alors α = arctan (Y/X) + π (il me semble).

 

(Le 3ème grand piège dans les calculs astronomiques, et le plus subtil, tu ne le rencontreras peut-être pas car il concerne les calculs liés à l'observateur : calcul du lever et du coucher, instant du passage au méridien, etc. Le piège, c'est la confusion entre temps moyen (journées de 24h) et temps sidéral (journées de 23h56m). Celui-là, il m'en a fait baver !)

 

Modifié par Bruno-
  • Merci 1

Partager ce message


Lien à poster
Partager sur d’autres sites

C'est vrai que j'ai arrondi très rapidement disons ^^

Super  ça fonctionne d'enfer ! Mais j'ai encore quelque interrogation...

 

Exemple pour le 1 janvier 2000 a 12 h 00 .00  pour Mercure  ( JD : 2451545) :

Le convertisseur en ligne donne :  (http://pgj.pagesperso-orange.fr/position-planetes.htm)

RA= 18h08m19.7s = 18,138610778 heures = 272.08 Degrés

DEC = -24°25'11.34''

 

Résultat de mon calcul avec vsop87 mercure version D donne :

Mercury Longitude in radians : 4.045026248245587
Longitude in degres : 231.76293204410973

Mercury Latitude in radians : -0.12081520741805907
Latitude in degres : -6.92220148605242

 

RA_rad : -2.3124504136790285
DEC_rad : -0.4286088586741546

RA_deg : 227.50635096291037
DEC_deg : -24.557478663948224

 

On remarque que le RA calculé ( 227.5 ) et différent du RA donné en ligne ( 272.08 ) D’où vient cette différence... ??  Voir mes calculs en fin de message ...

 

J'ai l'impression que les longitudes et latitudes donné par le convertisseur en ligne sont différentes de ce donné par vsop87 Mercure D ...

 

Je me suis dit je vais essayé de calcul les coordonnées de Venus avec la même technique que Mercure mais avec le vsop87 de venus version D bien sur, mais la le résultat et encore plus différent que les résultats donné par le convertisseur en ligne ....

 

Exemple pour le 1 janvier 2000 a 12 h 00 .00  pour Venus  ( JD : 2451545) :

Le convertisseur en ligne donne :  (http://pgj.pagesperso-orange.fr/position-planetes.htm)

RA= 15h59m34.77s =15,992777444 heures = 239.89 Degrés

DEC = -18°26'59.96''

 

Résultat de mon calcul avec vsop87 Venus version D donne :

Venus Longitude in radians : 3.187022183287107
Longitude in degres : 182.60292031692032

Venus Latitude in radians : 0.05697828490452141
Latitude in degres : 3.2646152489230458

 

dec_deg : 1.98882550755495

ra_deg : 183.67090718660307

 

 

Ici on remarque bien la différence entre les deux résultat ..... :/  ( DEC :   239.89  vs  1.98882550755495 ) 
 

Après du coup je me suis mis a chercher dans le livre calculs astronomiques de Jean MEEUS et j'ai trouver ce calcul pour obtenir la longitude héliocentriques Ecliptique a l'aide de vsop87  :

L = (tt.Venus_L0(t)+ tt.Venus_L1(t)*(t) + tt.Venus_L2(t)*Math.pow(t, 2) + tt.Venus_L3(t)*Math.pow(t, 3) + tt.Venus_L4(t)*Math.pow(t, 4)+ tt.Venus_L5(t)*Math.pow(t, 5))/Math.pow(10, 8);

Ce qui me donne : 3.1870221832871074E-8

 

Cela ne m'a pas l'aire bon non plus malheureusement ......

 

Voila, je vous remercie d'avance pour votre aide et j'espère avoir explicité clairement mes problèmes.

 

****************************************************************************************************************************************************************************************************************************------------------ CALCUL RA ET DEC -------------------------------------******************************************************************************

 

    // calcul de la Acension Droite ( RA) en radian
    static double RA_rad(double e, double longitude, double latitude) {
        double X;
        X = Math.cos(longitude) * Math.cos(latitude);
        double Y;
        Y = Math.cos(e) * Math.sin(longitude) * Math.cos(latitude) - Math.sin(e) * Math.sin(latitude);
        double ra_rad;
        ra_rad = Math.atan2(Y, X); // dans cette ordre X,Y
        return ra_rad ;
    }

    // calcul de la Declinaison en radian
    static double DEC_rad(double e, double longitude, double latitude) {
        double sin_dec;
        sin_dec = ((Math.sin(e)) * Math.sin(longitude) * Math.cos(latitude) + (Math.cos(e) * Math.sin(latitude)));
        double dec_rad;
        dec_rad = Math.asin(sin_dec);
        return dec_rad;
   

 

 

 

Partager ce message


Lien à poster
Partager sur d’autres sites

Tu utilises comme comparaison un site qui se base sur le livre de Meeus (c'est indiqué en bas de page) : ce n'est pas ce qu'il y a de plus précis (ça donne des résultats à quelques minutes d'arc près, ce qui est déjà pas mal). Tu peux utiliser un site professionnel, comme https://www.imcce.fr/fr/ephemerides/ . Il propose même plusieurs algorithmes dont le VSOP87 ( http://nsdb.imcce.fr/multisat/nssreq1hf.htm ). Fais attention aussi que les calculs, a priori, donnent des positions par rapport au centre de la Terre (« géocentre » sur le site) alors que, parfois, les publications donnent les coordonnées par rapport à un lieu donné.

 

Le site de l'IMCCE, avec l'algorithme VSOP87, donne : 

v17.11    Planète: Mercure  (INPOP17a)
Planète
Position d'observateur: Géocentre
Echelle de temps: UTC
L'equateur et équinoxe moyens de J2000.  ICRF. 
Coordonnées astrométriques 
      JD          alpha (h m s)      delta (º ' ")
 2451545.000000 18  8 20.452024  -24  25  13.370629

 

Quasiment les mêmes valeurs que http://pgj.pagesperso-orange.fr/position-planetes.htm , comme quoi les algorithmes simplifiés de Meeus tiennent la route !

 

Là, les coordonnées que tu trouves sont nettement différentes de la réalité, donc il y a clairement une erreur, ce n'est pas seulement une histoire de calculs imprécis.

 

Pour trouver l'erreur, il faudrait que tu décrives la méthode employée et indiques quelques données intermédaires. (Le bout de programme que tu as indiqué concerne le passage des coordonnées écliptiques aux équatoriales si j'ai bien compris, or le problème vient probablement avant.) Exemple fictif de ce que tu pourrais décrire :

 

1) Calcul des coordonnées écliptiques héliocentriques de Mercure : λ = 351,033°, β = +2,848°, Δ = 0,378505.

 

2) Calcul des coordonnées écliptiques héliocentriques de la Terre : λ0 = 85,359°, β0 = 0°, Δ0 = 0,998545.

 

3) Calcul des coordonnées héliocentriques cartésiennes de Mercure et de la Terre. X = ..., Y = ... et ainsi de suite.

 

4) D'où on en déduit les coordonnées géocentriques de Mercure : X = ..., Y = ... etc. (Géocentriques par rapport au centre de la Terre.)

 

5) Puis calcul des coordonnées écliptiques géocentriques de Mercure : l = ..., b = ..., r = ...

 

6) Et enfin calcul des coordonnées équatoriales...

 

Tu as bien suivi ce plan ?

 

Modifié par Bruno-

Partager ce message


Lien à poster
Partager sur d’autres sites

En faite je pense que mon problème vient de mon calcul pour la longitude et latitude : pour JD : 2451545

Exemple pour longitude :

JD_t = ((JD - 2451545) / 365250);

JD_t = ((2451545 - 2451545) / 365250); 

JD_t =  0.017876814586660537;

 

Après en utilisant les méthodes du programme fourni par vsop87 ( Mercury_L0(JD_t) )  cela me donne :

L0 = 4.4293481036110025
L1 =0.0
L2=0.0
L3 =0.0
L4 =-0.0
L5 =-0.0

 

Du conformément a la règle j’additionne tout les L ( ici ce n'a pas grand intérêt car les autres valeurs sont null):

cela donne

Longitude in radians : 4.035154791673375

Longitude in degrés : 231.19733924487534

Alors que ça devrais me donner  λ = 351,033 si j'avais le bon calcul ...

 

J'ai vue sur internet : Il faut ajouter 180° à λ si x est négatif. Mais au pire des cas ça donne 411,197339245 degrés dans mon cas. Ce qui n'est pas bon non plus ...

 

 

 

 

 

 

 

Partager ce message


Lien à poster
Partager sur d’autres sites

J'ai rien compris ! Tu parles de quelles longitude et latitude ?

 

Je me demande si tu n'aurais pas sauté quelques étapes. Normalement, le calcul des coordonnées éclitptiques héliocentriques se fait en plusieurs étapes :

‒ calcul de l'anomalie moyenne (c'est elle qui est donnée par des séries du type L = 3.144171 + 0.05058 T + 0.00071 T² - 0.0000002 T³) ;

‒ résolution de l'équation de Kepler et calcul de l'anomalie vraie ;

‒ calcul des coordonnées héliocentriques de la planète : longitude, latitude et rayon vecteur.

 

Pour trouver les coordonnées géocentriques, il faut connaître les coordonnées héliocentriques de la Terre, qu'on calcule de même (anomalie moyenne, anomalie vraie, coordonnées héliocentriques). Puis on fait le changement de variable (en passant en coordonnées cartésiennes). Etc. etc. etc.

 

Tu as fait tout ça ou pas ?

 

Modifié par Bruno-

Partager ce message


Lien à poster
Partager sur d’autres sites

Bonjour , Je reviens vers vous que maintenant car j’étais un peu perdu du coup j'ai décidé me relancer dans les calculs des éphémérides depuis le début (en utilisant la théorie vsop87 toujours ) et en suivant le livre je Jean Meeus - Calcul astronomiques à l'usage des amateurs et en suivant les conseils ci-dessus  de bruno ... Afin de réaliser les calculs et de pouvoir les vérifier, j'ai réalisé le même calcul que dans leurs exemple. C'est a dire que j'ai calculé l' ascension droite et la déclinaison ( la position apparente comme dit dans le livre )  de Venus pour le 20 décembre 1992 à 0h Temps dynamique = JJ 2448976.5

 

Après deux jours de calcul et de test j'arrive au bon résultat, c'est a dire :

rad en deg : 316.1767716972735
dec en deg : -18.88643717742539

 

Cependant mon calcul marche pour certaine date mais pas toutes ... et ça je ne comprend pas pourquoi ...

 

Je vous met mon calcul entiers et commenté avec les résultat à la fin . Merci d'avance  aux personnes qui prendrons le temps de se pencher sur le sujet, je leurs suis très reconnaissant ! Et pour les plus courageux je leurs met le fichier java en fichier joint si vous voulez tester. ( il suffit juste de l’exécuté dans votre éditeur  ) fichier : CompletVenusNow.java

Merci beaucoup !!!

 

Le code / Le calcul est le suivant :

package ephemeride;

public class CompletVenusNow {

    public static void main(String[] args) {
        
        CompletVenusNow tt = new CompletVenusNow();
        double tVenus;
        tVenus = (( 2448976.5 - 2451545) / 365250);
        
        /* ******** Coordonnées heliocentrique de venus en deg ********** */
        double L = (tt.Venus_L0(tVenus)+ tt.Venus_L1(tVenus) + tt.Venus_L2(tVenus) + tt.Venus_L3(tVenus) + tt.Venus_L4(tVenus)+ tt.Venus_L5(tVenus))*(180/Math.PI);
        if ( L < -360 ) {
            L = L+ (360 * Math.floor(L / 360)*-1) ;
        } else if (L > 0 ) {
            L = L- (360 * Math.floor(L / 360)) ;
        }
        System.out.println("\n heliocentrique L (deg) : " + L );
        
        double B = (tt.Venus_B0(tVenus)+ tt.Venus_B1(tVenus) + tt.Venus_B2(tVenus) + tt.Venus_B3(tVenus) + tt.Venus_B4(tVenus)+ tt.Venus_B5(tVenus))*(180/Math.PI);
        if ( B < -360 ) {
            B = B+ (360 * Math.floor(B / 360)*-1) ;
        } else if (L > 360 ) {
            B = B- (360 * Math.floor(B / 360)) ;
        }
        System.out.println(" heliocentrique B  (deg): " + B);
        
        double R = (tt.Venus_R0(tVenus)+ tt.Venus_R1(tVenus) + tt.Venus_R2(tVenus) + tt.Venus_R3(tVenus) + tt.Venus_R4(tVenus)+ tt.Venus_R5(tVenus));
        System.out.println(" heliocentrique R : " + R);
        
        /* ******** Coordonnées heliocentrique de venus en rad ********** */
        L = L *Math.PI / 180; // 0,45378560552 rad
        B = B *Math.PI / 180; // -0,03490658504 rad

        /* ******** Coordonnées heliocentrique de la terre en deg ********** */
        
        double Lo = (tt.Earth_L0(tVenus)+ tt.Earth_L1(tVenus) + tt.Earth_L2(tVenus) + tt.Earth_L3(tVenus) + tt.Earth_L4(tVenus)+ tt.Earth_L5(tVenus))*(180/Math.PI);
        if ( Lo < -360 ) {
            Lo = Lo+ (360 * Math.floor(Lo / 360)*-1) ;
        } else if (Lo > 0 ) {
            Lo = Lo- (360 * Math.floor(Lo / 360)) ;
        }
        System.out.println("\n heliocentrique  terre Lo (deg) : " + Lo );
        
        double Bo = (tt.Earth_B0(tVenus)+ tt.Earth_B1(tVenus) + tt.Earth_B2(tVenus) + tt.Earth_B3(tVenus) + tt.Earth_B4(tVenus)+ tt.Earth_B5(tVenus))*(180/Math.PI);
        if ( Bo < -360 ) {
            Bo = Bo+ (360 * Math.floor(Bo / 360)*-1) ;
        } else if (Bo > 360 ) {
            Bo = Bo- (360 * Math.floor(Bo / 360)) ;
        }
        System.out.println(" heliocentrique terre Bo  (deg): " + Bo);
        
        double Ro = (tt.Earth_R0(tVenus)+ tt.Earth_R1(tVenus) + tt.Earth_R2(tVenus) + tt.Earth_R3(tVenus) + tt.Earth_R4(tVenus)+ tt.Earth_R5(tVenus));
        System.out.println(" heliocentrique terre Ro : " + Ro);
        
        
        /* ******** Coordonnées heliocentrique de la terre en rad ********** */
    
        Lo = Lo *Math.PI / 180; // 1,53588974175
        Bo = Bo  *Math.PI / 180;
        Ro = Ro;
        
         /* ********************  Calcul    ********************/
        double X = (R * Math.cos(B) * Math.cos(L)) - (Ro * Math.cos(Bo) * Math.cos(Lo));
        double Y = (R * Math.cos(B) * Math.sin(L)) - (Ro * Math.cos(Bo) * Math.sin(Lo));
        double Z = (R * Math.sin(B)) - (Ro * Math.sin(Bo));

        System.out.println("x : " + X);
        System.out.println("y : " + Y);
        System.out.println("z : " + Z);

        /* ******** Vrai distance terre - venus ********** */
        double VraiDis = Math.sqrt((X * X) + (Y * Y) + (Z * Z));
        System.out.println("Vrai distance : " + VraiDis);
        
        /* ******** Temps lumière ( T)  ********** */
        double TempLum = 0.0057755183 * VraiDis;
        System.out.println("temps lumiere : " + TempLum);
        
        
        
        /* ******** Coordonnées heliocentrique de venus pour l'instant t-T en degres ********** */
        
        tVenus = (( (2448976.5 - TempLum ) - 2451545) / 365250);
   
        double L1 = (tt.Venus_L0(tVenus)+ tt.Venus_L1(tVenus) + tt.Venus_L2(tVenus) + tt.Venus_L3(tVenus) + tt.Venus_L4(tVenus)+ tt.Venus_L5(tVenus))*(180/Math.PI);
        if ( L1 < -360 ) {
            L1 = L1+ (360 * Math.floor(L1 / 360)*-1) ;
        } else if (L1 > 0 ) {
            L1 = L1- (360 * Math.floor(L1 / 360)) ;
        }
        System.out.println("\n heliocentrique L1 (deg  pour t-T): " + L1 );
        
        double B1 = (tt.Venus_B0(tVenus)+ tt.Venus_B1(tVenus) + tt.Venus_B2(tVenus) + tt.Venus_B3(tVenus) + tt.Venus_B4(tVenus)+ tt.Venus_B5(tVenus))*(180/Math.PI);
        if ( B1 < -360 ) {
            B1 = B1+ (360 * Math.floor(B1 / 360)*-1) ;
        } else if (L > 360 ) {
            B1 = B1- (360 * Math.floor(B1 / 360)) ;
        }
        System.out.println(" heliocentrique B1 (deg  pour t-T): " + B1);
        
        double R1 = (tt.Venus_R0(tVenus)+ tt.Venus_R1(tVenus) + tt.Venus_R2(tVenus) + tt.Venus_R3(tVenus) + tt.Venus_R4(tVenus)+ tt.Venus_R5(tVenus));
        System.out.println(" heliocentrique R1  : " + R1);
        
        /* ******** Coordonnées heliocentrique de venus pour l'instant t-T en rad ********** */
        L1 = L1 *Math.PI / 180; // 0,45378560552 rad
        B1 = B1 *Math.PI / 180; // -0,03490658504 rad

        double X1 = (R1 * Math.cos(B1) * Math.cos(L1)) - (Ro * Math.cos(Bo) * Math.cos(Lo));
        double Y1 = (R1 * Math.cos(B1) * Math.sin(L1)) - (Ro * Math.cos(Bo) * Math.sin(Lo));
        double Z1 = (R1 * Math.sin(B1)) - (Ro * Math.sin(Bo));

        System.out.println("\nx1 : " + X1);
        System.out.println("y2 : " + Y1);
        System.out.println("z3 : " + Z1);
        
        /* ******** Vrai distance terre - venus ( avec t-T )********** */
        double VraiDis1 = Math.sqrt((X1 * X1) + (Y1 * Y1) + (Z1 * Z1));
        System.out.println("Vrai distance1 : " + VraiDis1);

        /* ******** Temps lumière (T) ( avec t-T ) ********** */
        double TempLum1 = 0.0057755183 * VraiDis1;
        System.out.println("temps lumiere1 : " + TempLum1);

        /* ******** calcul longitude de venus ********** */
        double tan_longitude = Y1 / X1;
        double longitude = Math.atan(tan_longitude);
        double longitude_deg = (longitude * (180 / Math.PI)) + 360;
        System.out.println("\nlongitude en deg: " + longitude_deg );
        
        /* ******** calcul latitude de venus ********** */
        double tan_latitude = Z1 / (Math.sqrt((X1 * X1) + (Y1 * Y1)));
        double latitude = Math.atan(tan_latitude);
        double latitude_deg = latitude * (180 / Math.PI);
        System.out.println("latitude en deg: " + latitude_deg);

        double t = (((2448976.5 ) - 2451545) / 36525);

        /* ******** l'exentricité de le l'orbite de la terre (e) ********** */
        double e = 0.016708634 - 0.000042037 * t - 0.0000001267* (t*t) ;
        System.out.println("l'exentricité de le l'orbite de la terre (e) : " + e);

        /* ******** longitude du perihelie ( pi ) ********** */
        double pi =  102.93735 + 1.71947*t + 0.00046* (t*t) ;
        System.out.println("longitude du perihelie ( pi deg ) : " + pi);
        double piRad = pi * Math.PI / 180;
        System.out.println("piRad : " + piRad);

        /* ******** longitude geocentrique moyenne du soleil ( LO) ********** */
        double L0 = 280.46646 + 36000.76983 * t + 0.0003032 * (t * t);
        System.out.println("\nlong geo moyenne du soleil ( LO) : " + L0);

        /* ******** anomalie moyenne du soleil (M) ********** */
        double M = 357.52911 * Math.PI / 180 + (35999.05029 * Math.PI) / 180 * t
                - 0.0001537 * Math.PI / 180 * (t * t);
        System.out.println("anomalie moyenne du soleil ( M) : " + M);

        /* ******** centre du soleil (C) ********** */
        double C = (1.914602 - 0.004817 * t - 0.000014 * (t * t)) * Math.sin(M)
                + (0.019993 - 0.000101 * t) * Math.sin(2 * M) + 0.000289 * Math.sin(3 * M);
        System.out.println("centre du soleil : " + C);

        /* ******** Longitude Vrai du Soleil  ********** */
        double LongVraiSoleil = (L0 + C) - 360 * Math.floor((L0 + C) / 360);
        System.out.println("LongVraiSoleil : " + LongVraiSoleil);
        double LongVraiSoleilRad = LongVraiSoleil * Math.PI / 180;
        System.out.println("LongVraiSoleilRad : " + LongVraiSoleilRad);
        
        /* ******** constante de l'abberation  ********** */
        double K = ((20.49552 / 3600)*Math.PI)/180 ;
        System.out.println("K : " + K);
        
        /* ******************* **************************** Calcul Aberration  *********************************************************** */
        double Aberration_Longitude = (-K * Math.cos(LongVraiSoleilRad - longitude) + e * K * Math.cos(piRad - longitude)) / Math.cos(latitude) ;
        double Aberration_Longitude_deg = Aberration_Longitude* ( 180 / Math.PI) ;
        System.out.println("Aberration_Longitude_deg : " + Aberration_Longitude_deg );

        
        double Aberration_Latitude = -K * Math.sin(latitude)* (Math.sin(LongVraiSoleilRad - longitude) - e * Math.sin(piRad - longitude));
        double Aberration_Latitude_deg = (Aberration_Latitude * ( 180 / Math.PI))  ;
        System.out.println("Aberration_Latitude_deg : " +  Aberration_Latitude_deg);
         
        
        /* ******************* **************************** Longitude et latitude moins l'Aberration  *********************************************************** */
        double latitude_aberration = latitude_deg - Aberration_Longitude_deg ;
        double longitude_aberration = latitude_deg - Aberration_Latitude_deg ;
        
        
        /* *********** LongitudeMoyenneSoleil = L0  ***************** */
        L0 = L0 * (Math.PI / 180 ) ;
        /* *********** LongitudeMoyenneLune   ***************** */
        double LLune = (218.3164 + 481267.8812 * t + 0.001599* (t*t)) * (Math.PI / 180 );
        /* *********** anomalie moyenne du soleil  = M   ***************** */
        M = M  * (Math.PI / 180 );
        /* *********** anomalie moyenne de la lune     ***************** */
        double MLune = (134.9634 + 477198.8675 * t + 0.008721 * (t*t)) * (Math.PI / 180 ) ;
        
        /* *********** anomalie moyenne de la lune     ***************** */
        double omega = (125.0443 - 1934.1363 * t + 0.002075 * (t*t)) * (Math.PI / 180 ) ;
        
        /* *********** nutation de la longitude     ***************** */
        double nutation_longitude = 0 ;
        nutation_longitude += -(17.1996 + 0.01742 * t)* Math.sin(omega);
        nutation_longitude += -(1.3187 + 0.00016 *t) * Math.sin(2*L0) ;
        nutation_longitude += -0.2274 * Math.sin(2*LLune);
        nutation_longitude += +0.2062 * Math.sin(2*omega) ;
        nutation_longitude += +(0.1426 - 0.00034 *t) * Math.sin(M);
        nutation_longitude += +0.0712 * Math.sin(MLune);
        nutation_longitude += -(0.0517 - 0.00012 * t) * Math.sin(2 * L0 + M);
        nutation_longitude +=-0.0386 * Math.sin(2*LLune-omega);
        nutation_longitude += -0.0301 * Math.sin(2*LLune+MLune);
        nutation_longitude += +0.0217 * Math.sin(2*L0-M) ;
        nutation_longitude += -0.0158 * Math.sin(2*L0-2*LLune + MLune) ;
        nutation_longitude += +0.0129 * Math.sin(2*L0 - omega) ;
        nutation_longitude += +0.0123 * Math.sin(2*LLune - MLune) ;
        nutation_longitude = nutation_longitude / 3600;
        System.out.println("\nnutation_longitude en deg  : " + nutation_longitude); // 0,00444444444
            
        /* *********** nutation de la latitude     ***************** */
        double nutation_latitude = 0 ;        
        nutation_latitude +=  +(9.2025 + 0.00089*t) *  Math.cos(omega) ;
        nutation_latitude += +(0.5736 - 0.00031* t) * Math.cos(2 * L0) ;
        nutation_latitude += +0.0977 * Math.cos(2 * LLune) ;
        nutation_latitude += -0.0895 * Math.cos(2* omega) ;
        nutation_latitude += +0.0224 * Math.cos(2*L0 + M);         
        nutation_latitude += + 0.0200 * Math.cos(2*LLune-omega) ;
        nutation_latitude += +0.0129 * Math.cos(2*LLune + MLune) ;
        nutation_latitude += -0.0095 * Math.cos(2*L0 - M);
        nutation_latitude += -0.0070 * Math.cos(2 * L0 - omega);
        System.out.println("nutation_latitude : " + nutation_latitude); // deg -0,016666667
                
        /* *********** obliquité moyenne ( qui est non utilisé dans mon cas )   ***************** */        
        double ObliquitM= (23+ 26/60 + 21.448/3600 )- ( 46.8150 / 3600 ) *t - (0.00059/3600) *(t*t) + (0.001813/3600) *(t*t*t) ;
        System.out.println("ObliquitM : " + ObliquitM);
        
        /* *********** longitude corrigé pour la nutation     ***************** */
        double Longitude_nutation = longitude_deg  + nutation_longitude ;
        System.out.println( "Longitude_nutation :  " + Longitude_nutation);
        
        /* ***********  obliquité de l'écliptique     ***************** */
        double E = (23.4392911 * Math.PI / 180);
        
        /* ***********  Conversion de Longitude_nutation en radian       ***************** */
        Longitude_nutation = Longitude_nutation * Math.PI / 180 ;

        /* ***********  Calcul de l'Ascension droite       ***************** */
        double F;
        F = Math.cos(Longitude_nutation) * Math.cos(latitude);
        double G;
        G = Math.cos(E) * Math.sin(Longitude_nutation) * Math.cos(latitude) - Math.sin(E) * Math.sin(latitude);
        double ra_rad;
        ra_rad = Math.atan2(G, F); // dans cette ordre G,F
        System.out.println("rad en deg : "+ (ra_rad* ( 180 / Math.PI)+360 ));  ;
        
        
        
        /* ***********  Calcul de la Déclinaison     ***************** */  
        double sin_dec;
        sin_dec = ((Math.sin(E)) * Math.sin(Longitude_nutation) * Math.cos(latitude) + (Math.cos(E) * Math.sin(latitude)));
        double dec_rad;
        dec_rad = Math.asin(sin_dec);
        System.out.println("dec en deg : " + dec_rad * ( 180 / Math.PI));
    
        
    }

 

 

Le résultat est le suivant :

 


 heliocentrique L (deg) : 26.11411959514089
 heliocentrique B  (deg): -2.6206031211961918
 heliocentrique R : 0.7246016759555223

 heliocentrique  terre Lo (deg) : 88.3570045917113
 heliocentrique terre Bo  (deg): 1.662695729726217E-4
 heliocentrique terre Ro : 0.9838241642711414
x : 0.6217453110684215
y : -0.6648122386978192
z : -0.03313324305849642
Vrai distance : 0.9108459564347573
temps lumiere : 0.005260607489869944

 heliocentrique L1 (deg  pour t-T): 26.10571812103899
 heliocentrique B1 (deg  pour t-T): -2.620919380428602
 heliocentrique R1  : 0.7246023679452037

x1 : 0.6217924790901884
y2 : -0.6649073232679508
z3 : -0.0331372701491552
Vrai distance1 : 0.9109477011669834
temps lumiere1 : 0.005261195118432844

longitude en deg: 313.0808463015071
latitude en deg: -2.0846912526550136
l'exentricité de le l'orbite de la terre (e) : 0.01671158948664706
longitude du perihelie ( pi deg ) : 102.81643622562049
piRad : 1.794485337303849

long geo moyenne du soleil ( LO) : -2251.1687830825636
anomalie moyenne du soleil ( M) : -37.94319988043709
centre du soleil : -0.47236015117494784
LongVraiSoleil : 268.3588567662614
LongVraiSoleilRad : 4.683745627459124
K : 9.936508497454117E-5
Aberration_Longitude_deg : -0.004130095207340988
Aberration_Latitude_deg : -1.4747370015569854E-4

nutation_longitude en deg  : 0.004629498315663484
nutation_latitude : -1.9219445605245453
ObliquitM : 23.006872251866344
Longitude_nutation :  313.08547579982275
rad en deg : 316.1767716972735
dec en deg : -18.88643717742539

 

 

 

Modifié par nathan frad

Partager ce message


Lien à poster
Partager sur d’autres sites

Bizarre que ça marche pour certaines dates et pas pour d'autres. Quand tu dis que ça ne marche pas, tu veux dire que le résultat est moins précis, ou bien que le résultat n'a rien à voir ? Mettons que ce soit la deuxième hypothèse. Ça pourrait être une erreur de trigonométrie du genre : tel calcul est bien programmé uniquement si l'angle est entre 0° et 180°. Le programme entier n'aidera pas à moins de faire à ta place le débogage (pas moi : je ne connais pas le Java et je ne crois pas que le compilateur Java est installé sur ma machine).

 

Un truc possible pour trouver l'erreur, c'est de calculer la position de jour en jour jusqu'à tomber sur une position fausse. À la date précédente elle est juste, aujourd'hui elle est fausse. Et alors tu compares tous les résultats intermédiaires. Normalement, ceux de la position précédente sont différents mais de peu des résultats intermédiaires de la date présentes. Il se peut qu'à un moment donné les deux résultats intermédiaires (hier / aujourd'hui) divergent nettement : c'est là qu'est l'erreur. Le plus important est de la localiser, ensuite tu devrais trouver le pot aux roses. (Par exemple tu peux faire le calcul à la main ─ enfin, à la calculatrice ─ pour la partie où ça diverge afin de comparer avec le programme.)

 

J'ai quand même vu un truc suspect :

double tan_longitude = Y1 / X1;
double longitude = Math.atan(tan_longitude);

C'est probablement une des erreurs car l'arc tangente fournit un angle entre -π et π. Il faut corriger ça en faisant :

if (X1 < 0.0) longitude += 360.0; 

(si je ne me trompe pas) ou, mieux, utiliser une fonction atan2 (elle existe en C, je suis sûr qu'elle existe en Java). En C on écrit :

longitude = atan2(Y1, X1);

Ah oui, tu as utilisé atan2 un peu plus loin :

ra_rad = Math.atan2(G, F); // dans cette ordre G,F

Voilà, donc il faut faire de même pour la longitude. Je n'ai pas vu d'autres endroits avec ce genre d'erreur (les calculs de latitude peuvent, eux, utiliser atan tout court).

Modifié par Bruno-

Partager ce message


Lien à poster
Partager sur d’autres sites

Créer un compte ou se connecter pour commenter

Vous devez être membre afin de pouvoir déposer un commentaire

Créer un compte

Créez un compte sur notre communauté. C’est facile !

Créer un nouveau compte

Se connecter

Vous avez déjà un compte ? Connectez-vous ici.

Connectez-vous maintenant