jupyter notebook

$ pip install pyephem

import ephem as ep
#OBSERVATEUR
obs = ep.Observer()
# nous créons une structure dans laquelle des données
# sur la position de l'observateur seront stockées
obs.lon = "10.00"
obs.lat = "36.5"
obs.name = "SAT-Tunis"
obs.elevation = 100.0

# Objets
# nous créons une structure dans laquelle les données seront stockées
lune = ep.Moon()

# CALCULS
# on calcule la position actuelle de l'objet
# pour l'observateur créé plus tôt
lune.compute(obs)

# coordonnées calculées
print("Position actuelle de la Lune")
print(" ------------------------------ ")
# nous affichons l'ascension droite et la déclinaison
print("RA : ", lune.ra)
print("Dec : ", lune.dec)
# nous affichons l'azimut et l'élévation
print("--------------------------------")
print("Az : ", lune.az)
print ("El : " , lune.alt)

Position actuelle de la Lune
 ------------------------------
RA :  6:18:27.81
Dec :  20:49:04.9
--------------------------------
Az :  197:06:32.3
El :  56:50:39.8

# coordonnées azimutales en degrés sous forme d'un nombre réel
print(" -------------------------------- ")
print("Az (deg): ", degrees(lune.az))
print("El (deg): ", degrees(lune.alt))

--------------------------------
Az (deg):  207.85208210454263
El (deg):  55.334644372169485

# PROPRE DATE ET HEURE TU
obs.date = "2019/01/13 10:00:00"

# IMPORTATION
from pylab import *
import ephem as ep
# OBSERVATEUR
obs = ep.Observer()
# TUNIS
obs.lon, obs.lat, obs.elev = '10.08', '36.4', 100.0
obs.name= "SAT-TUNIS"
# OBJET
soleil = ep.Sun()
# TEMPS
tm = linspace(0 , 24 , 25)
# GRAPHIQUE
pt = subplot(111 , polar= True )

# BOUCLE PRINCIPALE
for t in tm :
    # changement de temps
    obs.date = "2014/06/21 %02 d :00:00 "%t
    # on calcule les coordonnées
    sun.compute(obs)
    # coordonnées azimutales - azimut en radians
    az = float(repr(sun.az))
    el = degrees(float(repr(sun.alt)))
    # graphique - on change l'élévation par une distance zénithale
    pt.plot([az], [90 - el], ls =" ", marker= " o ", c =" yellow ", \
    markersize =10)
    # heure locale UTC +2 heures en été
    if el > 0:
        pt.text (az, 90 - el, " %02 d "%(t+2), fontsize =10, \
        ha = 'left' , va = 'center')

    # TRANSFERT HIVERNAL - nous répétons les calculs "en décembre"
    obs.date = "2014/12/22 %02d:00:00" % t
    soleil.compute(obs)
    az = float(repr(soleil.az))
    el = degrees(float(repr(soleil.alt)))
    pt.plot([az], [90 - el], ls ="", marker= "o", c ="blue", \
    markersize =10)
    # heure locale UTC +1 heures en hiver
    if el > 0:
        pt.text (az, 90 - el, "%02d"%(t+1), fontsize =10, \
        ha = 'left' , va = 'center')
# nous limitons la distance zénithale à 90 degrés - horizon
plt.set_rmax(90.0)
# nous plaçons le nord en haut du graphique
plt.set_theta_zero_location("N")
# ENGISTREZ LE GRAPHIQUE EN FORMAT PDF ET PNG
plt.savefig("figs/mvtSoleil.pdf"); plt.savefig ("figs/mvtSoleil.png")
plt.show ()

# IMPORTATION
import ephem as ep
# deux fonctions supplémentaires du module datetime sont nécessaires
from datetime import datetime , timedelta

# OBSERVATEUR
obs = ep.Observer()
# COORDONNÉES DE TUNIS
obs.lon, obs.lat, obs.elev = '10.08', '36.4', 100.0
obs.name = "SAT-TUNIS"
# MARS
mr = ep.Mars()

from pylab import *
plt.figure(figsize=(10, 5))
for i in range (0 , 181):
    # nous changeons la date d'un jour pendant six mois
    dt = datetime (2018, 5, 1) + timedelta(i)
    ds = "%d/%02d/%02d"%(dt.year, dt.month, dt.day)
    print(" jour de l'année: ", i +1 , ds)
    # fixer la date de l'observateur et calculer les coordonnées
    obs.date = ds
    mr.compute(obs)
    ra = degrees(float(repr(mr.ra)))
    de = degrees(float(repr(mr.dec)))
    # on dessine des objets
    plot([ra], [de], c = "red", marker = "o", alpha =.5)
    # nous ajoutons une description de la date en moyenne tous les 10 jours
    if (dt.day % 10) == 0: text(ra, de, ds, fontsize =8)

# description du graphique
xlabel("ascension droite " + r"$\alpha$ (deg)")
ylabel(" déclinaison " + r"$\delta$ (deg)")
title("Mouvement retrograde de Mars - 6 mois en 2018 \n"+obs.name, fontweight='bold')
savefig("../figs/retrogradeMars.pdf"); savefig("../figs/retrogradeMars.png")
show()

# conversion RA donné en degrés
# sur les formats heure, minute et seconde
def RAd2hms (x, loc):
    h = x//15
    m = int(((x - h * 15.0) / 15.0) * 60.0)
    s = ((x - h *15 - m / 4.0) / 15.0) * 3600.0
    return "%02dh%02dm%02ds"%(h, m, s)
# changement de déclinaison donné en degrés
# le format du degré, minute, second arc
def DEd2dms (x , loc ):
    d = int(fabs(x))
    m = int((fabs(x) - d)*60)
    s = (fabs(x) - d - m /60.0)*3600.0
    if x <0: d = -1 * d
    return " %02dd%02dm%02ds"%(d, m, s)

# description du graphique
xlabel("ascension droite " + r"$\alpha$")
gca().xaxis.set_major_formatter(FuncFormatter(RAd2hms))
ylabel(" déclinaison " + r"$\delta$")
gca().yaxis.set_major_formatter(FuncFormatter(DEd2dms))
title("Mouvement retrograde de Mars - 6 mois en 2018 \n"+obs.name, fontweight='bold')

savefig("../figs/retrogradeMars.pdf"); savefig("../figs/retrogradeMars.png")
show()

# IMPORTATION
import ephem as ep
# NOUS CRÉONS LES OBJETS
Io = ep.Io()
Eu = ep.Europa()
Ga = ep.Ganymede()
Ca = ep.Callisto()
# Créons des tableaux vide pour
# SAUVEGARDER LES COORDONNÉES
y = []
xIo = []
xEu = []
xGa = []
xCa = []

# pas de temps - heure
dt = ep.hour
# temps initial
ts = ep.now()
# heure actuelle
tm = ts
N=2*24
for i in range(N):
    # nous calculons des valeurs y
    y.append((tm - ts)*24.0)
    # nous calculons des valeurs x
    Io.compute(tm)
    Eu.compute(tm)
    Ga.compute(tm)
    Ca.compute(tm)
    # nous ajoutons des calculs aux tableaux
    xIo.append(Io.x)
    xEu.append(Eu.x)
    xGa.append(Ga.x)
    xCa.append(Ca.x)
    # on augmente le temps d'une heure
    tm += dt

from pylab import *
fig1 = plt.figure()
plot(xIo, y, marker ="o", label ="Io")
plot(xEu, y, marker ="o", label ="Europa")
plot(xGa, y, marker ="o", label ="Ganimedes")
plot(xCa, y, marker ="o", label ="Callisto")
plot(zeros(len(y)),y ,marker =r"$\mathcircled{J}$", markersize =15,
     label ="Jupiter",color ="orange", fillstyle= 'none')
xlabel(u"position par rapport à Jupiter")
ylabel("Heures à partir de (%s TU)"% ts)
ylim(0,N+3)
title(u"Mouvement des lunes galiléennes")
grid()
legend(loc =1)

tight_layout()
savefig("../figs/mvtjov.pdf"); savefig("../figs/mvtjov.png")
show()

# IMPORTATION
import ephem as ep
# OBSERVATEUR
obs = ep.Observer()
obs.lon, obs.lat, obs.elev = '10.08', '36.4', 100.0
obs.name = "SAT-TUNIS"
# OBJETSNIS
soleil = ep.Sun()
lune = ep.Moon()
# pas de temps - heure
dt = ep.hour
# temps initial
#ts = ep.now()
ts=ep.Date("2015-01-01 00:00:00")
# heure actuelle
tm = ts

for i in range (365*24*10):
    # nous fixons l'heure actuelle
    obs.date = tm
    # nous calculons les coordonnées
    soleil.compute(obs)
    lune.compute(obs)
    # rayons
    rs = soleil.radius
    rl = lune.radius
    # on calcule la distance angulaire
    sp = ep.separation(soleil, lune)
    # on vérifie si la somme des rayons sera inférieure
    # à la séparation calculée
    if sp < rs + rl :
    # nous vérifions si le soleil sera au-dessus de l'horizon
        if soleil.alt > 0.0:
            print("Date de l'eclipse UT: ", ep.Date(tm), "Separation: ", sp)
    # on augmente le temps par pas d'une heure
    tm += dt

Date de l'eclipse UT:  2020/6/21 05:00:00 Separation:  0:30:50.0
Date de l'eclipse UT:  2022/10/25 10:00:00 Separation:  0:29:25.7
Date de l'eclipse UT:  2022/10/25 11:00:00 Separation:  0:30:51.9
Date de l'eclipse UT:  2025/3/29 11:00:00 Separation:  0:32:49.2
Date de l'eclipse UT:  2026/8/12 18:00:00 Separation:  0:20:53.8
Date de l'eclipse UT:  2027/8/2 08:00:00 Separation:  0:30:44.7
Date de l'eclipse UT:  2027/8/2 09:00:00 Separation:  0:04:33.3
Date de l'eclipse UT:  2027/8/2 10:00:00 Separation:  0:21:01.3
Date de l'eclipse UT:  2028/1/26 16:00:00 Separation:  0:26:09.8

# IMPORTATION
from pylab import *
import ephem as ep
# OBSERVATEUR
obs = ep.Observer()
# TUNIS
obs.lon, obs.lat, obs.elev = '10.08', '36.4', 100.0
obs.name= "SAT-TUNIS"
# CRÉER DES OBJETS
soleil = ep.Sun()
lune = ep.Moon()
# intervalle de temps - 20 minutes
dt = ep.hour/4.
# TEMPS DE DÉBUT
ts = ep.Date("2027-08-02 08:00:00")
obs.date = ts
# nous calculons les coordonnées
soleil.compute(obs)
lune.compute(obs)
rs = degrees(soleil.radius)
rl = degrees(lune.radius )

# nous calculons les coordonnées
soleil.compute(obs)
lune.compute(obs)
rs = degrees(soleil.radius)
rl = degrees(lune.radius )

# Nous créons un graphique en l'attribuant à un pl COMME variable
fig=plt.figure(figsize=(6,5))
pl = subplot(111, aspect ="equal")
# titre du graphique avec date et heure
pl.set_title (obs.name+"\n début en (TU): "+str(ep.Date(ts)))
# Nous nous plaçons le soleil dans le centre
sc=Circle((0 ,0), rs, facecolor ="yellow",
            edgecolor ="red", lw =2)

pl.add_artist(sc)
# les coordonnées du Soleil
pl.text(0, rs+0.1, "Az: %.1f, El: %.1f"%(degrees(soleil.az), degrees(soleil.alt)),
        ha='center', fontsize =14)

# Nous plaçons la Lune dans la figure
for i in range(10):
    print("time UT: ", ep.Date(ts))
    obs.date = ts
    # nous calculons les coordonnées
    soleil.compute(obs)
    lune.compute(obs)
    # Nous calculons la différence de position
    az = degrees(soleil.az - lune.az)
    el = degrees(soleil.alt - lune.alt)
    # dessiner et la position réelle en empillements d'image de Lune; le Soleil estau centre
    kc = Circle((az , el), rl , facecolor ="gray",
                edgecolor ="black", lw =2, alpha =0.3)
    pl.add_artist(kc)
    # augmenter le temps de 20 minutes
    ts += dt

pl.set_xlim (-1.0, 1.0)
pl.set_ylim (-1.0, 1.0)
pl.set_xlabel ("degré")
pl. set_ylabel ("degré")
plt.tight_layout()
savefig("../figs/eclipse_sol_" + str(ts) +".pdf"); savefig("../figs/eclipse_sol_" + str(ts) +".png")
show ()

# IMPORTOWANIE
from pylab import *
import ephem as ep
# OBSERVATEUR
obs = ep.Observer()
# TUNIS
obs.lon, obs.lat, obs.elev = '10.08', '36.4', 100.0
obs.name= "SAT-TUNIS"
# NOUS CRÉONS UN OBJET
# on vérifie si c'est sous l'horizon
soleil = ep.Sun()
lune = ep.Moon()
venus = ep.Venus()
mars = ep.Mars()
jupiter = ep.Jupiter()
# pas de temps - heure
dt = ep.hour
# temps initial
ts = ep.now()
# heure actuelle
tm = ts

# BOUCLE PRINCIPAL DU PROGRAMME
for i in range (365*24*1):
# nous fixons l'heure actuelle
    obs.date = tm
    # nous calculons des coordonnées
    soleil.compute(obs)
    lune.compute(obs)
    venus.compute(obs)
    mars.compute(obs)
    jupiter.compute(obs)
    # on calcule la séparation
    s1 = ep.separation(venus , lune)
    s2 = ep.separation(mars , lune)
    s3 = ep.separation(jupiter , lune)
    # la séparation doit être inférieure à 5 degrés
    if degrees(s1) < 5:
        # nous vérifions si la lune sera au-dessus de l'horizon
        # et si le soleil est au-dessous de l'horizon
        if degrees(lune.alt) > 5.0 and degrees(soleil.alt) < -5.0:
            print("-------------------------------------------------------------")
            print(u"précédente nouvelle lune , UT :", ep.previous_new_moon(ep.Date(tm)))
            print(u"Vénus - Lune , UT :", ep.Date(tm) ,"séparation :", s1)
            print(u"pos. Lune :", lune.az ,"El :", lune.alt)

if degrees(s2) < 5:
    if degrees(lune.alt) > 5.0 and degrees(soleil.alt) < -5.0:
        print("------------------------------------------------------------------")
        print(u"précédente nouvelle lune , UT :", ep.previous_new_moon(ep.Date(tm)))
        print(u"Mars - Lune , UT :", ep.Date(tm) ,"séparation :", s2)
        print(u"Pos. Lune, Az :", lune.az ,"El :", lune.alt)
if degrees(s3) < 5:
    if degrees(lune.alt) > 5.0 and degrees(soleil.alt) < -5.0:
        print("--------------------------------------------------------------")
        print(u"précédente nouvelle lune , UT :", ep.previous_new_moon(ep.Date(tm)))
        print(u"Jupiter - Lune , UT :", ep.Date(tm) ,"séparation :", s3)
        print(u"Pos. Lune, Az :", lune.az ,"El :", lune.alt)
    # on augmente le temps d'une heure
tm += dt

--------------------------------------------------------------
précédente nouvelle lune , UT : 2019/1/6 01:28:11
Jupiter - Lune , UT : 2019/1/31 03:47:21 séparation : 3:09:07.3
Pos. Lune, Az : 122:58:36.9 El : 8:18:03.0
--------------------------------------------------------------
précédente nouvelle lune , UT : 2019/2/4 21:03:35
Vénus - Lune , UT : 2019/3/3 04:47:21 séparation : 4:07:18.5
pos. Lune : 121:01:33.3 El : 6:15:18.7
--------------------------------------------------------------

conda install -c conda-forge cartopy

import datetime
import matplotlib.pyplot as plt
import cartopy.crs as ccrs
from cartopy.feature.nightshade import Nightshade
fig = plt.figure(figsize=(10, 5))
ax = fig.add_subplot(1, 1, 1, projection=ccrs.PlateCarree())
date = datetime.datetime(2019, 1, 13, 11)
ax.set_title('Night time shading for {}'.format(date))
ax.stock_img()
ax.add_feature(Nightshade(date, alpha=0.2))
plt.show()