Élongations des planètes en 2023 – Python

Un graphique d’éphémérides pour planifier l’observation des planètes.

Ce graphique est obtenu avec un script Python utilisant les modules :

  • matplotlib (graphiques)
  • ephem (calculs d’éphémérides astronomiques)
  • datetime (création et gestion de dates)

Le script est assez court. On peut modifier l’année au début du code :

import matplotlib.pyplot as plt#graphique
import numpy as np#gestion des listes et conversions degrés
import datetime as dt#gestion des dates
import matplotlib.dates as mdates#format des graduations de dates
from ephem import *#éphémérides

#------------------------------------------------------------------------------
annee=2023
date_debut=dt.datetime(annee, 1, 1)
date_fin=dt.datetime(annee, 12, 31)
#Création d'une liste de dates, appelée "epoque" :
epoque=[]
pas=dt.timedelta(days=2)#pas de temps, en jours
date=date_debut
while date<date_fin:
    epoque.append(date)
    date=date+pas
#------------------------------------------------------------------------------
plt.rcParams["font.family"] = "Ubuntu"#ou autre police installée sur l'ordinateur
#création de la figure et du graphique :
fig, ax=plt.subplots(tight_layout=True)
ax.set_title("Élongations des planètes en %i"%(annee), fontsize=18)
ax.invert_yaxis()#inversion du sens de l'axe y (dates descendantes)
ax.set_xlabel("Élongation (degrés)")
fig.set_size_inches(8, 12)#dimensions de la figure
ax.set_ylim(date_fin, date_debut)
ax.set_xlim(-180, 180)
ax.set_xticks(np.arange(-180, 180+20, 20))

#Mise en forme des graduations de dates en y :
locator1 = mdates.AutoDateLocator(minticks=15, maxticks=15)
formatter = mdates.ConciseDateFormatter(locator1)
ax.yaxis.set_major_locator(locator1)
ax.yaxis.set_major_formatter(formatter)
#------------------------------------------------------------------------------
#Liste des planètes et de leurs couleurs :
listeplanetes={
'Mercure':'slategray',
'Vénus':'slateblue',
'Mars':'orangered',
'Jupiter':'saddlebrown',
'Saturne':'darkgoldenrod', 
#'Uranus' : 'blue', 
#'Neptune' : 'darkblue'
}
#------------------------------------------------------------------------------

for planete in listeplanetes:
    elongation=[]
    for date in epoque:
        if planete=='Mercure':
            donnees=Mercury(date)
        elif planete=='Vénus':
            donnees=Venus(date)
        elif planete=='Mars':
            donnees=Mars(date)
            elong=-donnees.elong
        elif planete=='Jupiter':
            donnees=Jupiter(date)
        elif planete=='Saturne':
            donnees=Saturn(date)
#        elif planete=='Uranus':
#            donnees=Uranus(date)
#        elif planete=='Neptune':
#            donnees=Neptune(date)
        #fin de la distinction des planètes
        elong=-np.degrees(donnees.elong)#élongation positive pour le matin, négative pour le soir.
        elongation.append(elong)
    ax.scatter(elongation, epoque, s=4, c=listeplanetes[planete], label=planete)

ax.axvline(0, c='darkorange', lw=10)#ligne verticale (direction du Soleil)

ax.text(-30, dt.datetime(annee, 12, 25), "SOIR",  ha='center')
ax.text(30, dt.datetime(annee, 12, 25), "MATIN",  ha='center')

#Pour les légendes, deux options :
#Option 1 : légendes placées manuellement :
def legende(nom, x, date):
    ax.text(x, date, nom, c='white',  ha='center', fontsize=12, bbox=(dict(fc=listeplanetes[nom])))

#legende('Mercure', -45, dt.datetime(annee, 5, 1))
#legende('Vénus', 40, dt.datetime(annee, 7, 25))
#legende('Mars', 95, dt.datetime(annee, 10, 20))
#legende('Jupiter', -60, dt.datetime(annee, 1, 25))
#legende('Saturne', 120, dt.datetime(annee, 5, 22))
#Fin de l'option 1 des légendes
#Option 2 : légendes automatiques, mais personnalisées pour mieux voir les couleurs :
legendes=plt.legend(frameon=False, labelspacing=1.5)
for i,  texte in enumerate(legendes.get_texts()):
    texte.set(color='white', bbox=dict(fc=list(listeplanetes.values())[i]))
#Fin de l'option 2

plt.grid()
NomFichier="ElongationPlanetes"+str(annee)
fig.savefig(NomFichier+".png", dpi=200)
fig.savefig(NomFichier+".pdf")
plt.show()

Un résumé de l’année 2022 pour l’observation des planètes :

  • Les premiers jours de l’année, les 5 planètes seront visibles le soir, mais Mercure disparaît au bout de quelques jours.
  • Peu après le 15 janvier : rapprochement entre Vénus et Saturne, en début de soirée.
  • Début mars : rapprochement Vénus-Jupiter, en début de soirée.
  • Mi-février, Saturne disparaît en se couchant avec le Soleil, pour réapparaître le matin un mois plus tard.
  • Mars sera visible le soir presque toute l’année, en se couchant de plus en plus tôt.
  • Les oppositions de Saturne et de Jupiter, qui se produisent presque 1 fois par an, auront lieu fin août et début novembre, respectivement.
  • Vénus est en élongation maximale (meilleure visibilité) début juin (le soir) puis mi-octobre.

Avec ce code, il est facile de créer un document couvrant plusieurs années, ce qui permet de visualiser la période des phénomènes d’oppositions pour les planètes extérieures (presque chaque année pour Jupiter et Saturne, mais seulement tous les deux ans pour Mars).

Un complément, avec l’élongation de la Lune :

Cette version indique les rapprochements Lune – planète, ainsi que les dates des principales phases de la Lune.

Avec le module datetime, pour afficher les noms des jours et des mois en français, il faut ajouter en début de code les deux lignes suivantes :

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

Soyez le premier à commenter

Laisser un commentaire