Orbite elliptique d'un astre

[LFiacre]

Bonjour,  je souhaite obtenir la position d'un objet céleste en fonction d'une date sur le plan ecliptique. J'espère être dans la bonne section du forum pour mon problème.

Je programme en python et je découvre tout juste les bases de la mécanique céleste.

Mon problème se situe sur l'utilisation des formules comme les anomalies moyennes, excentriques et vraies. Connaissez-vous un site qui me permettrait de comparer mes résultats ?

Aussi j'ai glané les formules sur différents sites et sur wikipédia mais je ne suis pas sur qu'elles soient absolument correctes.

Mon objectif sera plus tard d'utiliser openGL pour simuler différentes trajectoires des planètes.

 

 

from math import sqrt, atan2, cos, sin, pi
import datetime

class Main:
    def __init__(self):
        self.G = 6.67430e-11
        self.UA = 149597870691 # mètre
        self.date = datetime.datetime(2021, 8, 24, 0, 0) # J2000
        self.t = self.date_julienne(self.date)
        
    def date_julienne(self, date):
        A = date.year
        M = date.month
        J = date.day
        H = date.hour
        if M <= 2:
            a = A - 1
            m = M + 12
        if M > 2:
            a = A
            m = M
        b = int(a/400)-int(a/100)
        DJ = int(365.25*a)+int(30.6001*(m+1))+b+1720996.5 +J+H*1.0/24
        t = (DJ - 2451545) / 36525
        return t
        
    def update(self):
        self.iteration = 0
        while self.iteration < 10:
            self.iteration += 1
            self.date += datetime.timedelta(hours=1)
            self.t += 1/24
            for obj in objets:
                obj.update()

class Sun:
    def __init__(self, pos, radius, mass):
        self.pos = pos # coordonnées cartésiennes 
        self.M  = mass # kg
        self.r = radius # mètre
    
class Planet:
    def __init__(self, name, a, e, i, node, arg_p, period, mass, radius):
        
        self.name = name
        self.a = a * main.UA # demi-grand axe
        self.e = e # excentricité
        self.i = i # inclinaison
        self.o = node # longitude noeud ascendant
        self.arg_p = arg_p # argument du périhélie
        self.m = mass # en kg
        self.r = radius # en mètre       
        self.p = node + arg_p # longitude périhélie                   
        self.Pa = self.a*(1-self.e**2) # paramètre de l'ellispe
        self.P = period # période de révolution
        self.n = 2*pi/self.P # moyen mouvement
        self.v_l = sqrt(2*main.G*self.m/self.r) # vitesse de libération
        print("\n", self.name,"\ndemi-grand axe: ", self.a,"mètre","\nexcentricité: ",self.e)
        print("inclinaison: ",self.i," deg","\nlongitude noeud ascendant: ",self.o," deg","\nargument périhélie: ",self.arg_p)
        print("longitude périhélie: ", self.p, " deg","\nparamètre de l'ellispe: ", self.Pa,"\npériode de révolution: ", self.P, " j")
        print("moyen mouvement: ", self.n,"\nvitesse de libération: ", self.v_l)

    def update(self):
        self.M = self.anomalie_moyenne()
        self.L = self.M + self.p # longitude moyenne
        self.E = self.anomalie_excentrique(self.M, self.e)
        self.v = self.anomalie_vraie(self.M, self.e)
        self.l = self.v + self.p # longitude vraie
        self.r = self.a*(1-self.e*cos(self.E*pi/180)) # rayon vecteur
        self.pos = self.position()
        self.info()

    def anomalie_moyenne(self):
        """ t: temps
            P: période révolution """
        M = (2*pi*main.t)/self.P
        if M > 360:
            M-= 360
        elif M < 0:
            M+=360
        return M

    def anomalie_excentrique(self, M, e):
        tolerance = 1e-09
        E1 = M *pi/180 # deg to rad
        answer = False
        while answer == False:
            E = M+e*sin(E1)
            if abs(E - E1) < tolerance:
                answer = True
            E1 = E
        while E > (2*pi):
            E = E - 2*pi
        return E

    def anomalie_vraie(self, M, e):
        """ M : anomalie moyenne en degrées
            e : excentricité """
        a1 = (2 * e - e**3/4) * sin(M*pi/180)
        a2 = 5/4 * e**2 * sin(2*M*pi/180)
        a3 = 13/12 * e**3 * sin(3*M*pi/180)
        v = M + (180/pi) * (a1 + a2 + a3)
        return v

    def position(self):
        """ passage des coordonnées polaires aux coordonnées cartésiennes """
        x = self.r * (cos(self.o) * cos(self.v + self.p - self.o) - sin(self.o) * sin(self.v + self.p - self.o) * cos(self.i))
        y = self.r * (sin(self.o) * cos(self.v + self.p - self.o) + cos(self.o) * sin(self.v + self.p - self.o) * cos(self.i))
        z = self.r * (sin(self.v + self.p - self.o) * sin(self.i))
        return (x, y, z)

    def info(self):
        print("\n",main.date)
        print("longitude moyenne: ", self.L, "deg")
        print("longitude vraie: ", self.l, "deg\n")
        print("anomalie moyenne: ", self.M)
        print("anomalie excentrique: ", self.E)
        print("anomalie vraie: ", self.v)
        print("rayon: ", self.r)
        print("pos: ",self.pos)

if __name__ == "__main__":

    main = Main()
    Soleil = Sun(pos=(0,0,0), radius=696340000, mass=198.9*10e28)
    # nom, demi-grand axe, excentricité, inclinaison, longitude noeud ascendant, argument_périhélie, periode révolution, masse, rayon
    Terre = Planet(name="Terre", a=1.00000261, e=0.01671123, i=-0.00001531, node=0.0, arg_p=114.20783, period=365.256363051, mass=59.736*10e23, radius=6371000)
    objets = [Terre]
    main.update()
    

 

Je vous remercie du temps que vous prendrez à me lire et je vous souhaite une bonne journée.

[arpège]

Regarde du coté du site de  l’Institut de mécanique céleste et de calcul des éphémérides (IMCCE)   https://www.imcce.fr/

et en programmation python.....https://rhodesmill.org/pyephem/index.html

en espérant que cela puisse t'aider à parfaire ton programme.

 

Modifié 24 août 2021 par arpège

[Fred_76]

Il y a le bouquin de Jean Meeus qui te donne toutes les bonnes formules.

 

https://www.amazon.fr/Calculs-astronomiques-à-lusage-amateurs/dp/2901730035

 

Tu devrais pouvoir le demander à la bibliothèque de ta fac. S’ils ne l’ont pas, ils pourront le demander.

[LH44]

Pour compléter la NASA propose de faire ces calculs en lignes pour tous les corps du système solaire et cela pour n'importe quelle époque via l'interface HORIZON, cela te permettra de les comparer avec tes résultats, tu peux sortir des fichiers CSV facilement interprétables en Python si besoin.

 

Je crois qu'on trouve difficilement le livre de Jean Meeus de nos jours mais on peut acquérir la version light et remasterisée à la SAF : Calculs astronomiques à l’usage des amateurs | Boutique de la SAF (saf-astronomie.fr) j'ai les 2 versions tout y es très bien expliqué (théories planétaires basées sur la VSOP87 notamment).

Modifié 26 août 2021 par LH44

[LFiacre]

Merci beaucoup arpège, le premier lien est justement ce qu'il me fallait. J'ai des résultats qui n'ont rien à voir, donc bon faut que je retravaille mon code.

Voici la sorti de mon code pour 10 positions sur 10 jours depuis le 25/08/21:

 Terre 
demi-grand axe:  1.00000261 mètre 
excentricité:  0.01671123
inclinaison:  -1.531e-05  deg 
longitude noeud ascendant:  0.0  deg 
argument périhélie:  114.20783
longitude périhélie:  114.20783  deg 
paramètre de l'ellispe:  0.9997233440630048 
période de révolution:  365.256363051  j
moyen mouvement:  0.017202124159305276
 2021-08-25 00:00:00 pos(au):  (0.4176320686747533, 0.8901939729647727, -1.3628869727155521e-05)
 2021-08-26 00:00:00 pos(au):  (0.4017308864688378, 0.8974821192654814, -1.374045124702809e-05)
 2021-08-27 00:00:00 pos(au):  (0.3857025766470299, 0.9044862576247018, -1.3847684605316133e-05)
 2021-08-28 00:00:00 pos(au):  (0.369552211365125, 0.9112041715898427, -1.3950535868130475e-05)
 2021-08-29 00:00:00 pos(au):  (0.3532849014038776, 0.9176337352858074, -1.4048972488323385e-05)
 2021-08-30 00:00:00 pos(au):  (0.3369057945516123, 0.9237729140877543, -1.4142963315788537e-05)
 2021-08-31 00:00:00 pos(au):  (0.32042007397510963, 0.9296197652649826, -1.4232478607318897e-05)
 2021-09-01 00:00:00 pos(au):  (0.3038329565793084, 0.9351724385957307, -1.4317490036019294e-05)
 2021-09-02 00:00:00 pos(au):  (0.28714969135630447, 0.9404291769527072, -1.4397970700270892e-05)
 2021-09-03 00:00:00 pos(au):  (0.27037555772418104, 0.9453883168591599, -1.4473895132244615e-05)

Et voici la sortie de l'IMCCE  :

Les positions que j'obtiens n'ont vraiment rien à voir dutout.

Aurrais-tu une remarque sur mon code, quelque chose qui te semblerait aberrant ?

Ton second lien est très intéréssant je vais non pas installer la librairie mais essayer de la lire sur github pour voir comment elle fonctionne.

Je te remercie du temps que tu as consacré à mon problème.

Je te souhaite une bonne journée

 

Merci Fred_76 et LH44, sur amazon il n'est plus en stock mais le lien saf-astronomie me paraît nickel.

Je vais me l'acheter !

 

Pour la sortie de mon code j'ai supprimé la conversion du demi-grand axe en mètre pour le conserver en au d'où les positions en au.

[philou31]

Est-ce que tu as testé le module AstroPy ?

Il fait vraiment bc de choses. 

On s'en est servi sur un projet au boulot il nous a fait gagner bc de temps. On a viré tout nos algos en c++ maison, pour les remplacer par des fcts du module AstroPy.

 

Même s'il ne répond pas directement à ta question il va te faire gagner bc de temps dans l'implémentation de tes algos. 

 

 

[LFiacre]

Bonjour philou31, je te remercie je fonce voir.

Mon objectif est surtout de comprendre comment ça fonctionne, c'est un projet perso où il n'y a aucun enjeu véritable à part le challenge. Et j'ai oublié de préciser que je suis en études littéraires donc les maths c'est laborieux pour moi mais j'espère arriver à quelquechose quand même. En faite je bloque sur les calculs d'anomalies vraies et les rayons parce qu’en fonction des articles que je lis, il ne présente pas le problème de la même manière.

Par exemple sur cet article: http://www.heliodon.net/downloads/Beckers_2010_Helio_006_fr_2.pdf, je suis largué à la page 6 alors que ça à justement l'air d'être le noeud du problème.

 

[arpège]

il y a une heure, LFiacre a dit :

 

Aurrais-tu une remarque sur mon code, quelque chose qui te semblerait aberrant ?

 

hélas, mes notions et mon niveau en Python restent très limités......

[LFiacre]

Mais sinon à ton avis avec l'excentricité 'e' et l'anomalie excentrique en degrée 'E', je peux calculer l'anomalie vraie ?

je trouve sur internet v = arctan(sqrt(1-e**2)*sin(E*pi/180))/(cos(E*pi/180)-e), est valide ?

 

 

[parenthèse]

n'étant pas particulièrement matheux et encore moins mathématicien je t'envoie le lien vers les bons vieux Cahier Clairaut  et qui  me semblent traiter ton problème.......http://clea-astro.eu/archives/cahiers-clairaut/CLEA_CahiersClairaut_028_10.pdf   ....un peu vieux mais une valeur sûre !🙂

sinon il y a les réponses à tes questions ici : https://mecaspa.cannes-aero-patrimoine.net/COURS_SA/ANOMALIE/ANOMALIE.htm

 

[LH44]

La réponse à ta question est dans le chap 34 page 241 du livre de Jean Meeus, il existe en PDF si tu ne l'a pas encore trouvé.

[arpège]

il y a une heure, LFiacre a dit :

Mais sinon à ton avis avec l'excentricité 'e' et l'anomalie excentrique en degrée 'E', je peux calculer l'anomalie vraie ?

je trouve sur internet v = arctan(sqrt(1-e**2)*sin(E*pi/180))/(cos(E*pi/180)-e), est valide ?

 

 

ta formule doit se retrouver à partir des informations données par Wikipedia mais j'ai la flemme de le vérifier  (https://fr.wikipedia.org/wiki/Anomalie_excentrique)

 

Modifié 24 août 2021 par arpège

['Bruno]

J'ai regardé rapidement. Je soupçonne que tu gères mal le temps. Il me semble que t représente le nombre de siècles juliens depuis J2000 (0 janvier 2000), donc cette formule est probablement fausse :

 

M = (2*pi*main.t)/self.P

Elle suppose que M=0 le 1er janvier. Que vaut self.P ? 365 jours ? 1 an ? 0.01 siècle ? Si t est en siècles juliens, P doit l'être aussi.

Normalement la formule de M commence par un terme constant (M le 0 janvier 2000).

[LFiacre]

Bruno, merci. A partir des cahiers Clairaut de parenthèse,  j'ai fait ça

def anomalie_moyenne(self):
        """ main.t: temps == 0.21644079397672827
            self.P: période de révolution == 365.256363051  
            self.t_0 = date passage périhélie == 0.21004220853296404
        """
        M = (360/self.P)*(main.t-self.t_0)
        if M > 360:
            M-= 360
        elif M < 0:
            M+=360
        return M # M donne alors == 0.006306504123607812 degrée

Est-ce juste ?

 

 

Voila comment j'obtiens main.t = (2021, 8, 24, 0, 0) et self.t_0 = (2021,1,2,7,48) avec t_0 un passage au périhélie

    def date_julienne(self, date):
        """ passage en date julienne"""
        A = date.year
        M = date.month
        J = date.day
        H = date.hour
        if M <= 2:
            a = A - 1
            m = M + 12
        if M > 2:
            a = A
            m = M
        b = int(a/400)-int(a/100)
        DJ = int(365.25*a)+int(30.6001*(m+1))+b+1720996.5 +J+H*1.0/24
        t = (DJ - 2451545) / 36525
        return t

 

[LFiacre]

J'ai simplifier mon code, les résultats produits sont toujours faux 😕

from math import sqrt, atan2, cos, sin, pi, atan, acos, asin
import datetime
# déclaration des fonctions
def anomalie_moyenne():
    """ t: temps
        n = moyen mouvement
        t_0 = date passage périhélie
        M en degrée"""
    M = n*(t-t_0)
    if M > 360:
        M-= 360
    elif M < 0:
        M+=360
    return M

def anomalie_excentrique(M, e):
    """ M: anomalie moyenne
        e : excentricité
    """
    tolerance = 1e-09
    E1 = M *pi/180 # degrée en radian
    answer = False
    while answer == False:
        E = M+e*sin(E1)
        if abs(E - E1) < tolerance:
            answer = True
        E1 = E
    while E > (2*pi):
        E = E - 2*pi
    return E
    
def anomalie_vraie(e, E):
    """ e: excentricité
        E : anomalie excentrique"""
    v_1 = acos((cos(E)-e)/(1-e*cos(E)))
    v_2 = asin((sqrt(1-e**2)*sin(E))/(1-e*cos(E)))
    # v_1 et v_2 ne donne pas le meme resultat, laquelle préférer ?
    return v_1

def date_julienne(date):
    """ conversion en date julienne"""
    A = date.year
    M = date.month
    J = date.day
    H = date.hour
    if M <= 2:
        a = A - 1
        m = M + 12
    if M > 2:
        a = A
        m = M
    b = int(a/400)-int(a/100)
    DJ = int(365.25*a)+int(30.6001*(m+1))+b+1720996.5 +J+H*1.0/24
    t = (DJ - 2451545) / 36525
    return t

# debut du code

G = 6.67430e-11 # constante gravitationnelle
date = datetime.datetime(2021, 8, 25, 0, 0)
t = date_julienne(date) # conversion en date julienne

# terre à J2000
a = 1.00000261 # demi-grand axe en au
e = 0.01671123 # excentricité
i = -0.00001531 # inclinaison
o = 0.0 # longitude noeud ascendant
arg_p = 114.20783 # argument périhélie
T = 365.256363051 # période de révolution
mass = 59.736*10e23 # masse de la terre en kg
t_0 = date_julienne(datetime.datetime(1899,12,31,12,0)) # date pos périhélie de la terre, peut-on s'en passer ?

p = o + arg_p # longitude périhélie                   
Pa = a*(1-e**2) # paramètre de l'ellispe

n = 2*pi/T # moyen mouvement ou 360/T

print("Terre J2000\n","\ndemi-grand axe: ", a,"au","\nexcentricité: ",e)
print("inclinaison: ",i," deg","\nlongitude noeud ascendant: ",o," deg","\nargument périhélie: ",arg_p)
print("longitude périhélie: ", p, " deg","\nparamètre de l'ellispe: ", Pa,"\npériode de révolution: ", T, " j")
print("moyen mouvement: ", n,"deg/day", "\ndate passage périhélie :",t_0,"\n")
        

itera = 0 # itération mise à 0
while itera < 2: 

    itera += 1 # augmente de 1 l'itération
    date += datetime.timedelta(days=1) # + 1 jours
    t = date_julienne(date) # date julienne

    M = anomalie_moyenne()
    L = M + p # longitude moyenne
    E = anomalie_excentrique(M, e)
    v = anomalie_vraie(e, E)
    l = v + p # longitude vraie
    r = a*(1-e*cos(E*pi/180)) # rayon vecteur

    # passage des coordonnées polaires aux coordonnées cartésiennes 
    x = r * (cos(o) * cos(v + p - o) - sin(o) * sin(v + p - o) * cos(i))
    y = r * (sin(o) * cos(v + p - o) + cos(o) * sin(v + p - o) * cos(i))
    z = r * (sin(v + p - o) * sin(i))
    pos = (x, y, z) # au
    print(date,"\npos x,y,z(au): ",pos, "\nrayon: ", r)

 

['Bruno]

Je te propose de poster ici, pour une date précise à indiquer, les valeurs des différentes données (anomalie moyenne, excentrique, etc.) Si possible, convertis-les en degrés. En tout cas, indique les unités, c'est primordial. D'ailleurs ça va t'obliger à vérifier que tu utilises les bonnes unités (une erreur classique...) Si des valeurs sont incohérentes, ça se verra assez vite. Et si j'ai le temps, je regarderai les détails ce week-end.

[philou31]

Au vu de ton profil plutôt littéraire la prise en main d'une librairie comme AstroPy peut être assez complexe et pas évidente. 

 

Elle pourrait te servir pour des conversions de base : le système de temps, certaines conversions de coordonnées, etc.....

 

J'ai bien compris que c'est un projet personnel et que tu as envie de tout refaire par toi même. 

 

Mais il y a vraiment des trucs ch....t en informatique et la gestion du temps en fait partie. La probabilité d'introduire des bugs dans la gestion du temps ou dans de la conversion de coordonnées est assez importante. 

 

[LH44]

Un conseil découpent bien les traitements, les conversions (écrire les méthodes idoines) de manière à les tester unitairement (et valider) chaque partie c'est comme cela que l'on avance dans un projet informatique on n'écrit jamais tout d'un coup pour appuyer sur le bouton marche / arrêt à la fin en espérant que ça fonctionne ou alors allumes un cierge avant on sait jamais   Commente aussi ton code pour décrire ce que tu fais, un commentaire du style "déclaration des fonctions" ne sert à rien   Dans le livre de Jean Meeus il y a des exemples concrets cela permet de bien valider que chaque partie de ton code est bon.

Modifié 26 août 2021 par LH44

[LFiacre]

Je vous remercie de vos conseils.

En fait il y a des choses que je n'arrive pas à comprendre même après lecture de ce que vous m'avez partagé. Par exemple cette formule pour la période orbitale où a est le demi grand axe en mètre,G la constante de gravitation et M1 et M2 la masse des deux objets en kg.

J'ai a = 149598261141.44247 mètre

G = 6.67430e-11

M1 = 1.989*10e30  kg # soleil

M2 = 5.9736*10e24 kg # terre

P = (2*pi)*sqrt((a**3)/(G*(M1+M2)))

Et j'obtiens P = 9978121.34495491, alors que j'espèrais obtenir 365.25 jours

Une fois résolue se problème de compréhension, je passerais à l'anomalie moyenne.

 

P=2πa3GM{\displaystyle P=2\pi {\sqrt {\frac {a^{3}}{GM}

[solfra]

Hello !

Ta formule est juste et donne le résultat en seconde.  Malgré ça ton résultat en seconde est faux, tu dois avoir une erreur de calcul dans ton code.

 

Voilà ce que j'ai codé en python :

 

from scipy import constants
import numpy as np
G = constants.G #constante de la gravitation
msol = 1.988E30 #masse du soleil
mterre = 5.972e24 #masse Terre
a = constants.au
P=2*np.pi*np.sqrt((a**3)/(G*(msol+mterre)))
print(P,"seconde")
Pj = P/(60*60*24)
print(Pj, "jours")

Et en sortie j'obtiens

31561921.841785897 seconde
365.3000213169664 jours

 

[LFiacre]

Merci solfra, j'avais pas pensé à ce que le résultat soit exprimé en seconde,  constants.au correspond à 149597870700 mètres ?

[LH44]

Il y a 6 heures, LFiacre a dit :

Je vous remercie de vos conseils.

En fait il y a des choses que je n'arrive pas à comprendre même après lecture de ce que vous m'avez partagé. Par exemple cette formule pour la période orbitale où a est le demi grand axe en mètre,G la constante de gravitation et M1 et M2 la masse des deux objets en kg.

 

Juste pour info ce qui tu as écris est la 3e loi de Kepler   

 

  

 

Etant donnée que la masse du soleil dépasse largement celle des planètes on peut considérer que pour toute les planètes du système solaire on a bien un constante ici.

Modifié 27 août 2021 par LH44

[solfra]

Il y a 1 heure, LFiacre a dit :

constants.au correspond à 149597870700 mètres ?

Oui, c'est 1 unité astronomique exprimé en mètre.  https://docs.scipy.org/doc/scipy/reference/constants.html#length

Le module constante de Scipy est très utile pour éviter d'écrire "à la main" tout un tas de constantes.

 

Il y a 1 heure, LFiacre a dit :

j'avais pas pensé à ce que le résultat soit exprimé en seconde

Comme tout le calcul est en unité SI ça m'ai paru naturel

Modifié 27 août 2021 par solfra

[LFiacre]

LH44, je suis pas sur de te suivre, c'est en supprimant M2 qu'on obtient une constante ?

Solfra, j'avais une erreur avec la masse du soleil que je notais e10*30 au lieu de e30, erreur bête de ma part.

['Bruno]

Il y a 5 heures, LFiacre a dit :

Une fois résolue se problème de compréhension, je passerais à l'anomalie moyenne.

 

Bonne idée de faire les choses pas à pas ! En plus, le langage Python est bien adapté à cette façon de procéder grâce à son interpréteur

 

Ah, ben tu as trouvé l'erreur (j'ai fait la même à l'instant) : c'est 1.989e30 qu'il faut utiliser comme notation.

 

------

Je pense que tu n'utilises pas la bonne valeur de a.

 

Avec tes données :

Citation

>>> MSol = 1.988e30    
>>> MTerre = 5.972e24  
>>> a = 149598261141.44247
>>> G = 6.67430e-11   
>>> P = 2 * pi * sqrt( a**3 / (G * (MSol + MTerre)) )
>>> P/86400                
365.2954308045195

 

Avec celles de Wikipédia :

Citation

>>> MSol = 1.9884e30
>>> MTerre = 5.9722e24
>>> a = 149597887.5e3
>>> G = 6.67430e-11
>>> P = 2 * pi * sqrt( a**3 / (G * (MSol + MTerre)) )
>>> P/86400
365.2573179760645

 

365.25 est plus précis que 365.295. Après, autant partir de la valeur exacte plutôt que de la recalculer.

 

Remarque : en négligeant la masse de la Terre et toujours avec les valeurs de Wikipédia on trouve 365.2578665045588. Ça rejoint la remarque de LH44.

[LH44]

il y a 27 minutes, LFiacre a dit :

LH44, je suis pas sur de te suivre, c'est en supprimant M2 qu'on obtient une constante ?

Solfra, j'avais une erreur avec la masse du soleil que je notais e10*30 au lieu de e30, erreur bête de ma part.

 

M1 = masse du soleil > M2 = masse de la planète, par exemple si l'on prend la masse de la plus grosse planète du système solaire Jupiter M2 = 2 . 10^27 kg, la masse du Soleil M1 = 2 . 10^30 donc on a un rapport de 1 pour 1000 on peut dire que M1+M2 est à peu près égale à M1 et le terme à droite de l'équation précédente ne dépend plus que de la masse du soleil et devient alors une constante pour toutes les planètes du système solaire (Jupiter est aussi 1000 fois plus massive que la Terre). Aussi dans un problème à 2 corps justement on ne tiens pas compte de l'influence gravitationnelle des planètes massives dans les équations de mouvement et cela par simplification. 

Modifié 27 août 2021 par LH44

[LFiacre]

J'apprends pleins de chose avec vous tous, j'ai lu la page wikipedia sur le SI et c'est super intéressant.

Je suis loin de réussir mon projet. Mais puis-je encore abuser de vous ?

Sur wikipedia je vois pour l'anomalie moyenne :

 

M=n(t−t0)=G(M⋆+m)a3(t−t0){\displaystyle M=n\,(t-t_{0})={\sqrt {\frac {G(M_{\star }\!+\!m)}{a^{3}}}}\,(t-t_{0})}

 

j'ai déjà calculé le moyen mouvement n =  0,01720 radians/jours.

Et c'est donc la gestion du temps qui me pose de nombreuses questions.

 

J'ai t = (2021, 8, 25, 0, 0)  = 2459451.5 jours julien : la date pour laquelle je veux la position de la terre

et t_0 =  (2021,1,2,13,53) = 2459217.07847 jours julien : l'instant du passage au périhélie

J'ai vérifié ma fonction de conversion de date UT en date julienne avec un convertisseur en ligne.

 

Dois-je passer le temps en seconde pour le système SI ?

Mais comment puis-je comparer mon résultat de l'anomalie moyenne pour savoir si je fais bien les choses, pour ensuite passer à l'anomalie excentrique ?

 

Je vous remercie infiniment de votre pédagogie et de votre patience avec moi.

 

 

['Bruno]

Si M est exprimé en radians, n est le nombre de radians par jour julien. Donc il ne faut pas le transformer en radians par secondes !

 

La règle, c'est d'avoir des unités cohérentes. En mécanique céleste il n'y a que trois sortes de grandeurs :

− les longueurs : mètres, kilomètres, UA ?

− les masses : toujours kilogrammes ;

− les durés : secondes, jours, années, siècles ?

Quant aux angles, c'est subtil (ce sont des grandeurs sans unité, mais on les exprime dans une unité...)

 

Dans une même formule, tu dois choisir une même unité pour chacun des trois grandeurs.

Exemple si M est en radians par jour, toutes les durées de la formule doivent être en jours.

 

Essaie de trouver n avec une précision plus grande, car la moindre imprécision sur ce paramètre va fortement se répercuter .

 

il y a une heure, LFiacre a dit :

Mais comment puis-je comparer mon résultat de l'anomalie moyenne pour savoir si je fais bien les choses, pour ensuite passer à l'anomalie excentrique ?

 

Voici un exemple tiré du livre de Meeus dont parlait Fred76. (Il a cité le géant mondial défiscalisé de la vente en ligne, mais on le trouve dans les magasins de chez nous − je l'avais acheté chez L'Astronome à Lorient). Ils s'agit des coordonnées du Soleil vu de la Terre. Pour celles de la Terre vue depuis le Soleil, il faudra ajouter 180° aux longitudes et anomalies.

 

10 avril 2014 à 19h21m temps dynamique

JJ = 2 546 758.306 25

L0 = 18.94800° (longitude moyenne du Soleil vu de la Terre)

M = 95.7652° (anomalie moyenne du Soleil)

e = 0.016702631 (excentricité)

ν = 97.66517° (anomalie vraie)

R = 1.00195 (distance Terre-Soleil)

λ = 20.84459° (longitude du Soleil vu de la Terre rapportée à l'équinoxe de la date, ie 2014)

[Fred_76]

 

il y a 29 minutes, 'Bruno a dit :

Il a cité le géant mondial défiscalisé de la vente en ligne, mais on le trouve dans les magasins de chez nous − je l'avais acheté chez L'Astronome à Lorient

Bah, il est épuisé chez Amazon… c’était juste pour la référence. Mais on le trouve facilement si on sait cliquer sur le bouquin.

[LH44]

L'éditeur avait fermé boutique jusqu'à son rachat il y a quelques jours par le propriétaire du magazine Sky&Telescope (US) mais l'ouvrage reste très difficile à dénicher ... sinon il en existe une version plus "light" éditée et vendue par la SAF et j'ai déjà donné le lien plus haut  

 

En attendant qu'il soit réimprimé : Astronomical Algorithms.pdf (agopax.it)

 

Et les algos codés en Python : GitHub - pavolgaj/AstroAlgorithms4Python: Python version of Meeus's Astronomical Algorithms

Modifié 27 août 2021 par LH44