Rétrogradation (de Mercure)

Dans les graphiques ci-dessous, cette page est une démonstration simplifiée de l'effet optique appelé "rétrogradation" des planètes, pour le cas particulier de Mercure.

La rétrogradation n'est pas une illusion d'optique, mais un effet réel, dû aux positions relatives de la Terre et de Mercure, et au fait que les deux se déplacent autour du Soleil.

Le même effet est observé pour les planètes extérieures (imaginez que vous êtes sur Mercure et que vous observez la Terre).

Dans cette simulation, l'"univers" est composé du Soleil (au centre), des planètes Mercure (rouge, sur le cercle intérieur) et Terre (bleu, sur le cercle intermédiaire), et des "étoiles lointaines" (un ensemble de cercles en pointillés à l'extérieur). Les "étoiles lointaines" constituent la toile de fond sur laquelle la rétrogradation est vue par une personne observant depuis la Terre.

Au début de la simulation, la Terre est à droite, Mercure est entre le Soleil et la Terre, et ne serait donc pas vraiment observable depuis la Terre à cause de la forte lumière du Soleil. Si elle pouvait l'être, elle ressemblerait à un petit point sur fond d'étoiles lointaines, et cette vue est représentée par le point rouge au contour blanc qui se trouve près des étoiles, tout à gauche.

Suggestion d'utilisation

Cliquez sur le Soleil pour lancer la simulation. Observez simplement le mouvement de l'image de Mercure contre les "étoiles lointaines" sans regarder la Terre ou Mercure.

Comme Mercure est plus proche du Soleil que la Terre, elle doit se déplacer plus rapidement pour éviter de tomber dans le Soleil : Mercure ne met que 88 jours pour effectuer une orbite, contre 365 pour la Terre. Elle va donc 4.15 fois plus vite.

Opération

Cliquez sur le Soleil pour mettre en pause ou reprendre la simulation.

Cliquez sur le Soleil en maintenant la touche option (alt) pour "réinitialiser" l'Univers.

Cliquez sur la Terre pour afficher/masquer la ligne de visée de l'observateur vers les "étoiles lointaines" (si vous avez du mal à cliquer sur la Terre lorsque la simulation est lancée, mettez-la en pause en cliquant d'abord sur le Soleil).

Dans cette simulation, la ligne de visée part toujours du centre de la Terre, passe par le centre de Mercure et aboutit à l'image observée, près des "étoiles lointaines".

Pour ceux qui sont intéressés par la façon dont la simulation est faite, une explication des calculs est donnée en dessous de la simulation. Les graphiques sont entièrement réalisés avec SVG (Scaleable Vector Graphics) et CSS (Cascading Style Sheets) plus un peu de JavaScript pour les animer.

Simulation

Notes

Les planètes réelles se déplacent sur des orbites elliptiques, et non circulaires. Toutefois, la différence est à peine perceptible.

Les planètes ne se déplacent pas non plus toujours à la même vitesse, elles vont plus vite lorsque dans leur orbite elles sont plus proches du Soleil, mais là encore, cela est à peine perceptible, en tout cas pas pour cette simulation.

Enfin, notez que la Terre et Mercure tournent toujours dans la même direction, et que ni l'une ni l'autre ne revient en arrière ou ne s'arrête dans son orbite. La rétrogradation est un effet purement optique.

Mathématiques

Voici comment les positions des éléments SVG sont calculées et comment ils sont déplacés.

Nous utilisons le système conventionnel de coordonnées orthogonales cartésiennes xy tel qu'utilisé en mathématiques, avec le Soleil comme origine, et les termes "vertical" et "horizontal" dans le sens habituel de "aligné sur l'axe y" et "aligné sur l'axe x".

Cependant, SVG utilise le stupide système d'infographie 2D dans lequel l'origine est en haut à gauche, l'axe y pointe vers le bas et les angles sont mesurés dans le sens des aiguilles d'une montre.

Nous effectuons les calculs dans le système mathématique habituel, puis juste avant l'affichage des éléments, leurs coordonnées sont converties dans le système graphique de la manière suivante

x_graphics = x₀+x

y_graphics = y₀−y

où x₀,y₀ sont les coordonnées graphiques du centre du Soleil.

Mouvement des planètes

Soit t le temps. Le temps commence à 0 et augmente régulièrement, par petits pas. Si les pas sont suffisamment petits, la simulation semble régulière.

La position d'une planète qui se déplace en douceur le long d'une trajectoire circulaire de rayon r est :

$x = r \cos (s t)$

$y = r \sin (s t)$

où s est un facteur indiquant la vitesse. Dans notre cas, nous devons seulement nous assurer que la vitesse de Mercure est 365/88 fois celle de la Terre, mais nous choisirons le pas de temps suffisamment petit pour que tout soit agréable à l'œil.

La ligne de visée

La ligne de visée depuis la Terre E jusqu'aux étoiles lointaines Q, en passant par Mercure M, peut être calculée à partir des positions de la Terre et de Mercure à chaque instant.

La ligne passant par les deux points E et M a une équation :

$y = (\frac{y_{E} - y_{M}}{x_{E} - x_{M}}) (x - x_{E}) + y_{E}$

en élaborant:

$y = (\frac{y_{E} - y_{M}}{x_{E} - x_{M}}) x + y_{E} - x_{E} (\frac{y_{E} - y_{M}}{x_{E} - x_{M}})$

avec:

$a = (\frac{y_{E} - y_{M}}{x_{E} - x_{M}})$

$b = y_{E} - x_{E} (\frac{y_{E} - y_{M}}{x_{E} - x_{M}})$

a étant la "pente", cela devient l'équation familière d'une ligne:

$y = a x + b$

Mais où touche-t-elle le cercle des "étoiles lointaines" ? Si ce cercle a un rayon R, il est défini par

$x^{2} + y^{2} = R^{2}$

En substituant la première dans la deuxième équation, on obtient une équation quadratique en x :

$x^{2} + {(a x + b)}^{2} - R^{2} = 0$

qui, une fois élaborée, devient

$(1 + a^{2}) x^{2} + 2 a b x + b^{2} - R^{2} = 0$

pour faciliter l'écriture du code, nous introduisons trois autres quantités intermédiaires A, B et C ::

$A = (1 + a^{2})$ $B = 2 a b$ $C = b^{2} - R^{2}$

ce qui donne l'équation quadratique bien connue :

$A x^{2} + B x + C = 0$

pour laquelle les deux solutions sont :

$x = \frac{- B \pm \sqrt{B^{2} - 4 A C}}{2 A}$

Malgré toutes ces manipulations mathématiques, le code JavaScript est remarquablement simple :

let a=(YE-YM)/(XE-XM); // the slope let b=YM-a*XM; let A=(1+a*a); let B=2*a*b; let C=b*b-R*R; let X1 = (-B + Math.sqrt(B*B-4*A*C))/(2*A); let X2 = (-B - Math.sqrt(B*B-4*A*C))/(2*A);

Cependant... Ce n'est pas fini, car nous devons décider laquelle de ces deux solutions choisir. Si la Terre est à droite de Mercure (comme dans le dessin ci-dessus) alors l'image est à gauche et nous devons choisir la solution négative, sinon nous devons choisir la solution positive :

if (XE>XM) { /* Earth at right, take negative */ (X1<0) ? XQ=X1 : XQ=X2 ; } else { /* right */ (X1>=0) ? XQ=X1 : XQ=X2 ; }; YQ = a*XQ+b;

Et cela nous donne la position de l'image de Mercure sur la toile de fond des "étoiles lointaines".

Mais ce n'est toujours pas tout ! La pente de la droite EA devient infinie lorsque les planètes sont sur une ligne verticale. Par conséquent, nous devons utiliser l'équation y=F(x) pour calculer y à partir de x lorsque la pente n'est pas trop importante, et utiliser x=F(y) lorsque la pente est grande. Ceci est facilement décidé en comparant la distance entre les planètes le long de l'axe x et le long de l'axe y.

Le code complet est alors :

H = Math.abs(XE-XM); V = Math.abs(YE-YM); if (H>V) { // Mercury is left or right of Earth; XE-XM is reasonably large but YE-YM may go through zero; use y=F(x) let a=(YE-YM)/(XE-XM); // the slope let b=YM-a*XM; let A=(1+a*a); let B=2*a*b; let C=b*b-R*R; let X1 = (-B + Math.sqrt(B*B-4*A*C))/(2*A); let X2 = (-B - Math.sqrt(B*B-4*A*C))/(2*A); if (XE>XM) { /* Earth at right, take negative */ (X1<0) ? XQ=X1 : XQ=X2 ; } else { /* right */ (X1>=0) ? XQ=X1 : XQ=X2 ; }; YQ = a*XQ+b; } else { // Mercury is above or below Earth; YM-YE is reasonably large but XM-XE may go through zero; compute x from y let a=(XE-XM)/(YE-YM); // the slope let b=XM-a*YM; let A=(1+a*a); let B=2*a*b; let C=b*b-R*R; let Y1 = (-B + Math.sqrt(B*B-4*A*C))/(2*A); let Y2 = (-B - Math.sqrt(B*B-4*A*C))/(2*A); if (YE>YM) { /* Earth at top, take negative */ (Y1<0) ? YQ=Y1 : YQ=Y2 ; } else { /* right */ (Y1>=0) ? YQ=Y1 : YQ=Y2 ; }; XQ = a*YQ+b; }; MercuryImage.setAttribute("cx",XQ+X0); MercuryImage.setAttribute("cy",Y0-YQ); LineOfSight.setAttribute("d","M"+(XQ+X0)+","+(Y0-YQ)+" L"+(XE+X0)+","+(Y0-YE) );

Ceci est calculé pour chaque pas de temps.

styles:	JS debugging:	Local Storage:
Desktop	OFF	Local Storage: