Satellites galiléens – Python

Où l’on calcule et affiche les positions des satellites galiléens relativement à Jupiter

Voici une nouvelle utilisation de Python et de son module Pyephem de calculs astronomiques, pour tracer les positions des 4 principaux satellites de Jupiter, à des dates données :

Ici, on récupère les positions x (horizontale), y (verticale) et z (profondeur) des 4 satellites, pour placer les points sur les graphes.

Les dates sont créées grâce au module datetime , avec un pas temporel réglable (timedelta). Le code Python parcourt les graphiques en incrémentant la date du pas indiqué.

Les conventions de signe du module Pyephem sont telles que x est positif vers l’Est et y positif vers le bas. Pour que les positions sur les graphes reflètent l’observation, le code Python prend les opposés de ces coordonnées (ou aurait pu tout aussi bien inverser les sens des axes).

Les valeurs de z sont passées comme paramètre zorder (ordre d’affichage, par superposition de couches). Ainsi, en cas de transit ou d’occultations de satellites, l’aspect des points reflète les positions réelles (voir image ci-dessus : le 3 janvier, Europe est occultée, et le 6 janvier Io occultée).

Le plan orbital moyen des satellites étant relativement incliné, j’ai fait le choix de recentrer les positions sur l’axe horizontal du graphique. Si j’avais pris toutes les ordonnées nulles, les positions relatives en y des satellites auraient été perdues. Au lieu de cela, j’ai créé une fonction qui opère une rotation des positions d’un angle constant (entré comme paramètre).

Malheureusement, la valeur de l’angle est à déterminer par tâtonnements ; elle dépend de l’époque d’observation.

Comment opère cette fonction de rotation ?

Je fais appel au module cmath qui gère les nombres complexes. Les coordonnées (x,y) d’origine sont utilisées pour créer un nombre complexe (partie réelle x et imaginaire y). Je crée ensuite un second nombre complexe de même module R mais d’argument augmenté de l’angle de rotation.

Enfin, la fonction retourne les parties réelle et imaginaire de ce second nombre complexe.

def rotation(x0, y0):#renvoie les coordonnées x, y d'un point après rotation d'angle 'angle'
    z=complex(x0, y0)
    R, theta=cmath.polar(z)
    Z2=cmath.rect(R, theta+angle)
    return Z2.real, Z2.imag

Le résultat permet de retrouver les positions des satellites dessinées par Galilée en janvier – février 1610 :

Pour comparer aux dessins de Galilée, il faut prendre en compte l’heure d’observation. Dans ce code Python, les heures sont en Temps Universel. Galilée indiquait les heures écoulées depuis le coucher du Soleil, avec parfois des dessins espacés de quelques heures qui montraient des variations notables de certaines positions.

Voir la source suivante pour une excellente analyse des observations de Galilée, par comparaison des positions calculées avec ses dessins.

Le code complet à télécharger :


Une version avec des dates indépendantes pour chaque graphe :

Ici, les dates et heures choisies sont celles indiquées par Galilée lui-même dans Sidereus Nuncius (mars 1610), à quelques minutes près. Galilée a indiqué les heures italiques, c’est-à-dire les heures écoulées depuis le coucher du Soleil. À Padoue, à cette période, le Soleil se couchait vers 15h50. Ainsi, l’indication “à deux heures de la nuit” se comprend comme vers 18 h.

Le document ci-dessous peut donc être comparé aux dessins de Galilée pour les mêmes dates.

listeDates=[#D'après Sidereus Nuncius, de Galilée
dt.datetime(1610, 1, 7, 17), 
dt.datetime(1610, 1, 8, 17), 
dt.datetime(1610, 1, 10, 17), 
dt.datetime(1610, 1, 11, 17), 
dt.datetime(1610, 1, 12, 17), 
dt.datetime(1610, 1, 13, 17), 
dt.datetime(1610, 1, 15, 19), 
dt.datetime(1610, 1, 15, 23), 
dt.datetime(1610, 1, 16, 17), 
dt.datetime(1610, 1, 17, 16, 30), 
dt.datetime(1610, 1, 17, 20, 30), 
dt.datetime(1610, 1, 18, 16, 20), 
dt.datetime(1610, 1, 19, 18, 00), 
dt.datetime(1610, 1, 19, 21), 

]
G=len(listeDates)

Une fois la liste de dates créées, le programme crée autant de graphiques que d’éléments dans la liste, et les dispose en colonnes. On peut modifier un peu le code afin d’avoir un affichage en 2 colonnes de graphiques.


Une version destinée à estimer les périodes de rotation des satellites. Les dates initiale et finale sont à modifier librement. Vu la différence de périodes entre Io et Callisto, on peut facilement retirer un/des satellites du code, et adapter la longueur de la plage temporelle.

Les graduations de temps s’adaptent à peu près automatiquement à la plage temporelle, mais quelques ajustements peuvent être nécessaires (voir commentaires du code).


Une version qui trace, pour une date donnée, les positions des satellites sur leur orbite, avec la même échelle que sur la vue latérale :

En atelier astronomie, on peut préparer des documents pour plusieurs dates, en séparant les deux graphes, pour demander aux élèves de faire correspondre les vues.

Pour obtenir deux graphes avec exactement la même échelle en largeur, je crée le graphe du bas en prenant comme coordonnées celles du premier graphe (largeur = 1).

Avec le module datetime, si vous avez besoin d’afficher le nom du mois, il sera par défaut en anglais. Pour afficher les noms des jours et des mois en français, il faut ajouter ces deux lignes en début de code :

import locale
locale.setlocale(locale.LC_ALL, 'fr_FR.UTF-8')#dates en français

Soyez le premier à commenter

Laisser un commentaire