// METHODES PUBLIQUES
/// <summary>
/// Calcule les paramètres d'une planète pour le lieu d'observation et la date de calcul spécifié. La méthode effectue tous les calculs du synoptique
/// une seule fois sans calcul itératif de convergence pour les heures de lever et de coucher. Les calculs nécessitent un objet Soleil qui est automatiquement
/// créé par la méthode.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
public void CalculerNonIteratif(PositionTemps a_lieuEtDateCalcul)
{
Soleil soleil = new Soleil();
soleil.CalculerNonIteratif(a_lieuEtDateCalcul);
CalculerNonIteratif(a_lieuEtDateCalcul, soleil);
}
/// <summary>
/// Calcule les paramètres d'une planète pour le lieu d'observation et la date de calcul spécifié. La méthode effectue tous les calculs du synoptique
/// de façon itérative jusqu'à convergence des heures de lever et de coucher.
/// Les calculs nécessitent un objet Soleil qui est automatiquement créé par la méthode.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
/// <returns>Résultat du succès (true) ou de l'échec (false) du calcul de convergence des heures de lever et de coucher.</returns>
public bool CalculerIteratif(PositionTemps a_lieuEtDateCalcul)
{
Soleil soleil = new Soleil();
soleil.CalculerNonIteratif(a_lieuEtDateCalcul);
return(CalculerIteratif(a_lieuEtDateCalcul, soleil));
}
// Algorithme 26
/// <summary>
/// Calcule les corrections dues à la parallaxe à apporter sur les coordonnées équatoriales géocentriques d’un corps céleste à partir des coordonnées rectangulaires géocentriques du lieu d’observation,
/// des coordonnées équatoriales géocentriques du corps céleste, de l’heure sidérale locale et de la distance du corps céleste à la Terre
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
protected void CalculerCorrectionCoordonneesEquatorialesParallaxe(PositionTemps a_lieuEtDateCalcul)
{
// Déclaration des variables de la méthode
double sinpi = 0, H; // variables de calcul
double x, y; // variables de calcul
// Calcul de la parallaxe
if (type == TypeCorpsCeleste.LUNE)
{
sinpi = (6378.14 / r);
}
if (type != TypeCorpsCeleste.LUNE)
{
sinpi = (Math.Sin(Maths.DegToRad(8.794 / 3600.0)) / r);
}
// Calcul de l'angle horaire
H = Maths.CalculerHeureDecimale(a_lieuEtDateCalcul.HeureSideraleLocale) - ascensionDroiteGeocentrique.Decimale;
H = Maths.Modulo(H, TypeAngle.ANGLE_HEURES_24);
H = 15.0 * H; // H en degrés
// Calcul des corrections à apporter sur les coordonnées équatoriales géocentriques
y = -a_lieuEtDateCalcul.LieuObservation.CosPhi * sinpi * Math.Sin(Maths.DegToRad(H));
x = Math.Cos(Maths.DegToRad(declinaisonGeocentrique.Decimale)) - a_lieuEtDateCalcul.LieuObservation.CosPhi * sinpi * Math.Cos(Maths.DegToRad(H));
deltaAlpha6 = Math.Atan2(y, x);
declinaisonTopocentrique = new Angle(Maths.RadToDeg(Math.Atan(((Math.Sin(Maths.DegToRad(declinaisonGeocentrique.Decimale)) - a_lieuEtDateCalcul.LieuObservation.SinPhi * sinpi) * Math.Cos(deltaAlpha6))
/ (Math.Cos(Maths.DegToRad(declinaisonGeocentrique.Decimale)) - a_lieuEtDateCalcul.LieuObservation.CosPhi * sinpi * Math.Cos(Maths.DegToRad(H))))), TypeAngle.ANGLE_DEGRES_90);
deltaDelta6 = declinaisonTopocentrique.Decimale - declinaisonGeocentrique.Decimale;
deltaAlpha6 = Maths.RadToDeg(deltaAlpha6) / 15.0;
}
// Algorithme 14
/// <summary>
/// Calcule les coordonnées horizontales topocentriques d’un corps céleste en coordonnées équatoriales topocentriques à partir de latitude et de l’heure sidérale vraie locale.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
protected void ConvertirCoordonneesHorizontalesVersEquatoriales(PositionTemps a_lieuEtDateCalcul)
{
// Déclaration des variables de la méthode
double H = 0.0; // variable de calcul
// Calcul de la décinaison topocentrique
double decTop = Math.Asin((Math.Sin(Maths.DegToRad(altitudeTopocentrique.Decimale)) * Math.Sin(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale)))
+ (Math.Cos(Maths.DegToRad(altitudeTopocentrique.Decimale)) * Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale)) * Math.Cos(Maths.DegToRad(azimutTopocentrique.Decimale))));
decTop = Maths.RadToDeg(decTop);
declinaisonTopocentrique = new Angle(decTop, TypeAngle.ANGLE_DEGRES_90);
// Calcul de l'angle horaire
if (Math.Sin(Maths.DegToRad(azimutTopocentrique.Decimale)) <= 0)
{
H = Math.Acos((Math.Sin(Maths.DegToRad(altitudeTopocentrique.Decimale)) - Math.Sin(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale))
* Math.Sin(Maths.DegToRad(declinaisonTopocentrique.Decimale))) / (Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale)) * Math.Cos(Maths.DegToRad(declinaisonTopocentrique.Decimale))));
H = Maths.RadToDeg(H);
}
if (Math.Sin(Maths.DegToRad(azimutTopocentrique.Decimale)) > 0)
{
H = Math.Acos((Math.Sin(Maths.DegToRad(altitudeTopocentrique.Decimale)) - Math.Sin(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale))
* Math.Sin(Maths.DegToRad(declinaisonTopocentrique.Decimale))) / (Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale)) * Math.Cos(Maths.DegToRad(declinaisonTopocentrique.Decimale))));
H = 360 - Maths.RadToDeg(H);
}
// Calcul de l'ascension droite topocentrique
H = H / 15.0; // Conversion de H en heures
double alphaTop = Maths.CalculerHeureDecimale(a_lieuEtDateCalcul.HeureSideraleLocale) - H;
alphaTop = Maths.Modulo(alphaTop, TypeAngle.ANGLE_HEURES_24);
ascensionDroiteTopocentrique = new Angle(alphaTop, TypeAngle.ANGLE_HEURES_24);
}
// ***** ALGORITHME 18P *****
/// <summary>
/// Calcule les corrections dues à la précession à apporter sur les coordonnées équatoriales géocentriques géométriques d’un corps céleste rapportées à l’équinoxe J2000
/// à partir du Jour Julien des Ephémérides correspondant à la date et l’heure considérées, des coordonnées équatoriales géocentriques géométriques du corps céleste à
/// l’époque J2000 et des corrections dues au mouvement propre.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
private void CalculerCorrectionCoordonneesEquatorialesPrecession(PositionTemps a_lieuEtDateCalcul)
{
// Déclaration des variables de la méthodes
double T, dzeta, z, teta, A, B, C; // variables de calcul
// Calcul du nombre de siècles depuis le 1,5 janvier 2000
T = (a_lieuEtDateCalcul.JourJulienEphemerides - 2451545.0) / 36525.0;
// Calcul de l'angle eta
dzeta = 2306.2181 * T + 0.30188 * T * T + 0.017998 * T * T * T; // angle en secondes d'arc
dzeta = dzeta / 3600.0; // angle en degrés
// Calcul de l'angle pi
z = 2306.2181 * T + 1.09468 * T * T + 0.018203 * T * T * T; // angle en secondes d'arc
z = z / 3600.0; // angle en degrés
// Calcul de l'angle p
teta = 2004.3109 * T - 0.42665 * T * T - 0.041833 * T * T * T; // angle en secondes d'arc
teta = teta / 3600.0; // angle en degrés
// Calcul de l'angle A
A = Math.Cos(Maths.DegToRad(objetCielProfond.DeltaJ2000.Decimale + deltaDelta1)) * Math.Sin(Maths.DegToRad(15.0 * (objetCielProfond.AlphaJ2000.Decimale + deltaAlpha1) + dzeta));
// Calcul de l'angle B
B = Math.Cos(Maths.DegToRad(teta)) * Math.Cos(Maths.DegToRad(objetCielProfond.DeltaJ2000.Decimale + deltaDelta1)) * Math.Cos(Maths.DegToRad(15.0 * (objetCielProfond.AlphaJ2000.Decimale + deltaAlpha1) + dzeta)) - Math.Sin(Maths.DegToRad(teta)) * Math.Sin(Maths.DegToRad(objetCielProfond.DeltaJ2000.Decimale + deltaDelta1));
// Calcul de l'angle C
C = Math.Sin(Maths.DegToRad(teta)) * Math.Cos(Maths.DegToRad(objetCielProfond.DeltaJ2000.Decimale + deltaDelta1)) * Math.Cos(Maths.DegToRad(15.0 * (objetCielProfond.AlphaJ2000.Decimale + deltaAlpha1) + dzeta)) + Math.Cos(Maths.DegToRad(teta)) * Math.Sin(Maths.DegToRad(objetCielProfond.DeltaJ2000.Decimale + deltaDelta1));
// Calcul de la correction à apporter sur l'ascension droite géocentrique géométrique rapportée à l'équinoxe J2000
deltaAlpha2 = (Maths.Modulo(Maths.RadToDeg(Math.Atan2(A, B)) + z, TypeAngle.ANGLE_DEGRES_360) / 15.0) - deltaAlpha1 - objetCielProfond.AlphaJ2000.Decimale;
// Calcul de la correction à apporter sur la déclinaison géocentrique géométrique rapportée à l'équinoxe J2000
deltaDelta2 = Maths.RadToDeg(Math.Asin(C)) - deltaDelta1 - objetCielProfond.DeltaJ2000.Decimale;
}
// Algorithme 5
/// <summary>
/// Calcule l’heure à Greenwich (heure TU) correspondant à une heure sidérale vraie à Greenwich à une date donnée par le Jour Julien à 0h TU
/// à partir de l’obliquité moyenne et des corrections en nutation
/// Si TU est proche de 0h TU, l'argument a_essai à 1 permet d'essayer d'incrémenter le temps TU de 23h56min04s.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
/// <param name="a_essai">Incrémentation de l'heure TU de 23h56min04s lorsque cet argument prend une valeur de 1 pour forcer la 2ème solution possible si l'heure TU est proche de 0h.</param>
protected void CalculerHeuresTULeverCoucher(PositionTemps a_lieuEtDateCalcul, int a_essai)
{
// Déclaration des variables de la méthode
double GSTm, T, T0, A; // variables de calcul
// Calcul de l'heure sidérale moyenne à Greenwich du lever
GSTm = HeureSideraleVraieAGreenwichLever - ((a_lieuEtDateCalcul.NutationLongitude * Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.ObliquiteMoyenne + a_lieuEtDateCalcul.NutationObliquite))) / 15.0);
GSTm = Maths.Modulo(GSTm, TypeAngle.ANGLE_HEURES_24);
// Calcul de l'heure sidérale moyenne à Greenwich à 0h TU
T = (a_lieuEtDateCalcul.JourJulien0h - 2451545.0) / 36525.0; // Calcul du nombre de siècles depuis le 1,5 janvier 2000
T0 = 6.6973745583 + 2400.0513369072 * T + 0.0000258622 * T * T - (1 / 580645161.0) * T * T * T;
T0 = Maths.Modulo(T0, TypeAngle.ANGLE_HEURES_24);
// Calcul de l'heure à Greenwich du lever
A = GSTm - T0;
A = Maths.Modulo(A, TypeAngle.ANGLE_HEURES_24);
heureTULever = A * 0.9972695663;
// Cas où la convergence du calcul itératif du lever à échoué (la fonction appelante passe alors l'argument essai à 1)
if ((heureTULever < ((3.0 / 60.0) + (56.0 / 3600.0))) && (a_essai == 1))
{
heureTULever = heureTULever + (23.0 + (56.0 / 60.0) + (4.0 / 3600.0));
heureTULever = Maths.Modulo(heureTULever, TypeAngle.ANGLE_HEURES_24);
}
// Calcul de l'heure sidérale moyenne à Greenwich du coucher
GSTm = heureSideraleVraieAGreenwichCoucher - ((a_lieuEtDateCalcul.NutationLongitude * Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.ObliquiteMoyenne + a_lieuEtDateCalcul.NutationObliquite))) / 15.0);
GSTm = Maths.Modulo(GSTm, TypeAngle.ANGLE_HEURES_24);
// Calcul de l'heure à Greenwich du coucher
A = GSTm - T0;
A = Maths.Modulo(A, TypeAngle.ANGLE_HEURES_24);
heureTUCoucher = A * 0.9972695663;
// Cas où la convergence du calcul itératif du coucher à échoué (la fonction appelante passe alors l'argument essai à 1)
if ((heureTUCoucher < ((3.0 / 60.0)) + (56.0 / 3600.0)) && (a_essai == 1))
{
heureTUCoucher = heureTUCoucher + (23.0 + (56.0 / 60.0) + (4.0 / 3600.0));
heureTUCoucher = Maths.Modulo(heureTUCoucher, TypeAngle.ANGLE_HEURES_24);
}
// Cas où le corps céleste est TOUJOURS VISIBLE ou TOUJOURS INVISIBLE, forçage de l'heure TU à TOUJOURS_VISIBLE ou TOUJOURS_INVISIBLE
if (heureSideraleVraieLocaleLever == TOUJOURS_VISIBLE)
{
heureTULever = TOUJOURS_VISIBLE;
}
if (heureSideraleVraieLocaleLever == TOUJOURS_INVISIBLE)
{
heureTULever = TOUJOURS_INVISIBLE;
}
if (heureSideraleVraieLocaleCoucher == TOUJOURS_VISIBLE)
{
heureTUCoucher = TOUJOURS_VISIBLE;
}
if (heureSideraleVraieLocaleCoucher == TOUJOURS_INVISIBLE)
{
heureTUCoucher = TOUJOURS_INVISIBLE;
}
}
// ***** ALGORITHME 17 *****
/// <summary>
/// Calcule les corrections dues à la précession à apporter sur les coordonnées écliptiques géocentriques géométriques d’un corps céleste rapportées
/// à l’équinoxe J2000 à partir du Jour Julien des Ephémérides correspondant à la sate et l’heure considérées et des coordonnées écliptiques géocentriques
/// géométriques du corps céleste rapportées à l’équinoxe J2000.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
private void CalculerPrecessionEcliptiques(PositionTemps a_lieuEtDateCalcul)
{
// Déclaration des variables de la méthode
double T, eta, pi, p, A, B, C; // variables de calcul
// Calcul du nombre de siècles depuis le 1,5 janvier 2000
T = (a_lieuEtDateCalcul.JourJulienEphemerides - 2451545.0) / 36525.0;
// Calcul de l'angle eta
eta = 47.0029 * T - 0.03302 * T * T + 0.000060 * T * T * T; // angle en secondes d'arc
eta = eta / 3600.0; // angle en degrés
// Calcul de l'angle pi
pi = 174.876384 - 869.8089 * T + 0.03536 * T * T; // angle en secondes d'arc
pi = pi / 3600.0; // angle en degrés
// Calcul de l'angle p
p = 5029.0966 * T + 1.11113 * T * T - 0.000006 * T * T * T; // angle en secondes d'arc
p = p / 3600.0; // angle en degrés
// Calcul de l'angle A
A = Math.Cos(Maths.DegToRad(eta)) * Math.Cos(Maths.DegToRad(betaGeometrique)) * Math.Sin(Maths.DegToRad(pi - lambdaGeometrique)) - Math.Sin(Maths.DegToRad(eta)) * Math.Sin(Maths.DegToRad(betaGeometrique));
// Calcul de l'angle B
B = Math.Cos(Maths.DegToRad(betaGeometrique)) * Math.Cos(Maths.DegToRad(pi - lambdaGeometrique));
// Calcul de l'angle C
C = Math.Cos(Maths.DegToRad(eta)) * Math.Sin(Maths.DegToRad(betaGeometrique)) + Math.Sin(Maths.DegToRad(eta)) * Math.Cos(Maths.DegToRad(BetaGeometrique)) * Math.Sin(Maths.DegToRad(pi - lambdaGeometrique));
// Calcul de la correction à apporter sur la longitude écliptique géocentrique géométrique rapportée à l'équinoxe J2000
deltaLambda2 = Maths.Modulo(p + pi - Maths.RadToDeg(Math.Atan2(A, B)), TypeAngle.ANGLE_DEGRES_360) - lambdaGeometrique;
// Calcul de la correction à apporter sur la latitude écliptique géocentrique géométrique rapportée à l'équinoxe J2000
deltaBeta2 = Maths.RadToDeg(Math.Asin(C)) - betaGeometrique;
}
// ***** ALGORITHME 38 *****
/// <summary>
/// Calcule l’anomalie vraie et le rayon vecteur d’une comète non périodique rapportés à l’équinoxe J2000 à partir du Jour Julien des Ephémérides
/// correspondant à la date et l’heure considérées, de la distance de la comète à la Terre, du Jour Julien des Ephémérides du passage de la
/// comète au périhélie et du périhélie de la comète.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
private void CalculerAnomalieVraieEtRayonVecteurParabolique(PositionTemps a_lieuEtDateCalcul)
{
// Déclaration des variables de la méthode
double D, W, s; // variables de calcul
double precision; // variable de calcul
// Calcul du nombre de jours écoulés depuis le passage de la comète au périhélie
D = (a_lieuEtDateCalcul.JourJulienEphemerides - 0.0057755183 * r) - jourJulienEphemeridePP;
// Calcul du paramètre W
W = (0.03649116245 * D) / (parametresOrbitaux.Perihelie * Math.Sqrt(parametresOrbitaux.Perihelie)); // W est en radians
// Calcul du paramètre s (s*s*s +3s -W = 0)
s = W / 3.0;
do
{
s = (2 * s * s * s + W) / (3 * (s * s + 1));
precision = s * s * s + 3 * s - W;
}while (precision > 0.0000000001 || precision < -0.0000000001);
// Calcul de l'anomalie vraie de la comète rapportée à l'équinoxe J2000
anomalieVraie = new Angle(Maths.RadToDeg(2 * Math.Atan(s)), TypeAngle.ANGLE_DEGRES_360);
// Calcul du rayon vecteur de la comète
rSoleil = parametresOrbitaux.Perihelie * (1 + s * s);
}
// Algorithme 7
/// <summary>
/// Calcule les heures sidérales vraies de lever et de coucher à Greenwich à partir des heures sidérales vraies locales de lever et de coucher et de la longitude du lieu d’observation.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
protected void CalculerHeuresSideralesVraiesAGreenwichLeverCoucher(PositionTemps a_lieuEtDateCalcul)
{
// Calcul des heures sidérales vraies à Greenwich de lever et de coucher
heureSideraleVraieAGreenwichLever = heureSideraleVraieLocaleLever - (a_lieuEtDateCalcul.LieuObservation.Longitude.Decimale / 15.0);
heureSideraleVraieAGreenwichLever = Maths.Modulo(heureSideraleVraieAGreenwichLever, TypeAngle.ANGLE_HEURES_24);
heureSideraleVraieAGreenwichCoucher = heureSideraleVraieLocaleCoucher - (a_lieuEtDateCalcul.LieuObservation.Longitude.Decimale / 15.0);
heureSideraleVraieAGreenwichCoucher = Maths.Modulo(heureSideraleVraieAGreenwichCoucher, TypeAngle.ANGLE_HEURES_24);
// Cas où le corps céleste est TOUJOURS VISIBLE ou TOUJOURS INVISIBLE, forçage de l'heure GST à TOUJOURS_VISIBLE ou TOUJOURS_INVISIBLE
if (heureSideraleVraieLocaleLever == TOUJOURS_VISIBLE)
{
heureSideraleVraieAGreenwichLever = TOUJOURS_VISIBLE;
}
if (heureSideraleVraieLocaleLever == TOUJOURS_INVISIBLE)
{
heureSideraleVraieAGreenwichLever = TOUJOURS_INVISIBLE;
}
if (heureSideraleVraieLocaleCoucher == TOUJOURS_VISIBLE)
{
heureSideraleVraieAGreenwichCoucher = TOUJOURS_VISIBLE;
}
if (heureSideraleVraieLocaleCoucher == TOUJOURS_INVISIBLE)
{
heureSideraleVraieAGreenwichCoucher = TOUJOURS_INVISIBLE;
}
}
// METHODES PRIVEES
/// <summary>
/// Calcule les paramètres d'une planète pour le lieu d'observation et la date de calcul spécifié. La méthode effectue tous les calculs du synoptique
/// une seule fois sans calcul itératif de convergence pour les heures de lever et de coucher.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
/// <param name="a_terreSoleil">Objet Soleil calculé pour le lieu d'observation et la date du calcul.</param>
/// <param name="a_essai">Incrémentation de l'heure TU de 23h56min04s lorsque cet argument prend une valeur de 1 pour forcer la 2ème solution possible si l'heure TU est proche de 0h.</param>
private void CalculerNonIteratif(PositionTemps a_lieuEtDateCalcul, CorpsSystemeSolaire a_terreSoleil, int a_essai)
{
// Déclaration des variables locales de la méthode
double distanceCalculPrecedent; // variable de calcul
double precision; // variable de calcul
do
{
distanceCalculPrecedent = r;
CalculerCoordonneesEcliptiquesEtRayonVecteur(a_lieuEtDateCalcul, type); // Algorithme 33
CalculerDistanceALaTerre(a_terreSoleil); // Algorithme 34
precision = r - distanceCalculPrecedent;
} while (precision > 0.0000000001 || precision < -0.0000000001);
CalculerCoordonneesEcliptiquesGeocentriquesGeometriques(a_terreSoleil); // Algorithme 15
CalculerCorrectionsCoordonneesEcliptiquesAberration(a_lieuEtDateCalcul, a_terreSoleil); // Algorithme 20
CalculerCoordonneesEcliptiquesGeocentriques(a_lieuEtDateCalcul, deltaLambda4, deltaBeta4); // Algorithme 22
ConvertirCoordonneesEcliptiquesVersEquatoriales(a_lieuEtDateCalcul); // Algorithme 12
ConvertirCoordonneesEquatorialesVersHorizontales(a_lieuEtDateCalcul, true); // Algorithme 13
CalculerRefractionAtmospherique(a_lieuEtDateCalcul); // Algorithme 24
ConvertirCoordonneesHorizontalesVersEquatoriales(a_lieuEtDateCalcul); // Algorithme 14
CalculerCorrectionCoordonneesEquatorialesRefraction(); // Algorithme 25
CalculerCorrectionCoordonneesEquatorialesParallaxe(a_lieuEtDateCalcul); // Algorithme 26
CalculerCoordonneesEquatorialesTopocentriques(); // Algorithme 27
ConvertirCoordonneesEquatorialesVersHorizontales(a_lieuEtDateCalcul, false); // Algorithme 13
CalculerTaillePhaseMagnitude(a_lieuEtDateCalcul, a_terreSoleil); // Algorithme 35
CalculerHeuresSideralesEtAzimutsLeverCoucher(a_lieuEtDateCalcul, r, taille.Decimale); // Algorithme 28
CalculerHeuresSideralesVraiesAGreenwichLeverCoucher(a_lieuEtDateCalcul); // Algorithme 7
CalculerHeuresTULeverCoucher(a_lieuEtDateCalcul, a_essai); // Algorithme 5
CalculerHeuresLocalesLeverCoucher(a_lieuEtDateCalcul); // Algorithme 2
}
// Algorithme 28
/// <summary>
/// Calcule les heures sidérales vraies et les azimuts topocentriques de lever et de coucher d’un corps céleste à partir des coordonnées équatoriales géocentriques, de la latitude du lieu d’observation
/// et dans le cas des corps du système solaire (en particulier le Soleil et la Lune) de la distance à la Terre et de la taille apparente.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
/// <param name="a_r">Distance à la Terre du corps céleste (cas des corps célestes dans le système solaire), mettre n'importe quelle valeur autrement ou utiliser la méthode surchargée).</param>
/// <param name="a_taille">Taille apparente du corps céleste (cas des corps célestes dans le système solaire), mettre n'importe quelle valeur autrement ou utiliser la méthode surchargée).</param>
protected void CalculerHeuresSideralesEtAzimutsLeverCoucher(PositionTemps a_lieuEtDateCalcul, double a_r, double a_taille)
{
// Déclaration des variables de la méthode
double parallaxe, nu, cosH, H; // variables de calcul
// Calcul de la parallaxe
switch (type)
{
case TypeCorpsCeleste.J2000:
parallaxe = 0.0;
break;
case TypeCorpsCeleste.LUNE:
parallaxe = Maths.RadToDeg(Math.Asin((6378.14 / a_r)));
break;
default:
parallaxe = Maths.RadToDeg(Math.Asin((Math.Sin(Maths.DegToRad(8.794 / 3600.0)) / a_r)));
break;
}
// Calcul du paramètre nu
nu = parallaxe - (34.0 / 60.0) - (a_taille / 2.0);
// Calcul de l'angle horaire
cosH = (Math.Sin(Maths.DegToRad(nu)) - Math.Sin(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale)) * Math.Sin(Maths.DegToRad(declinaisonGeocentrique.Decimale)))
/ (Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale)) * Math.Cos(Maths.DegToRad(declinaisonGeocentrique.Decimale)));
if (cosH < -1) // Cas où le corps céleste est toujours visible
{
heureSideraleVraieLocaleLever = TOUJOURS_VISIBLE;
heureSideraleVraieLocaleCoucher = TOUJOURS_VISIBLE;
}
if (cosH > 1) // Cas où le corps céleste est toujours invisible
{
heureSideraleVraieLocaleLever = TOUJOURS_INVISIBLE;
heureSideraleVraieLocaleCoucher = TOUJOURS_INVISIBLE;
}
if ((cosH > -1) && (cosH < 1)) // Cas où le corps céleste se lève et se couche
{
H = Maths.RadToDeg(Math.Acos(cosH));
H = H / 15.0; // H en heures
// Calcul de l'heure sidérale vraie locale et de l'azimut de lever
heureSideraleVraieLocaleLever = ascensionDroiteGeocentrique.Decimale - H;
heureSideraleVraieLocaleLever = Maths.Modulo(heureSideraleVraieLocaleLever, TypeAngle.ANGLE_HEURES_24);
azimutLever = Maths.RadToDeg(Math.Acos((Math.Sin(Maths.DegToRad(declinaisonGeocentrique.Decimale)) - Math.Sin(Maths.DegToRad(nu)) * Math.Sin(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale)))
/ (Math.Cos(Maths.DegToRad(nu)) * Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale)))));
// Calcul de l'heure sidérale vraie locale et de l'azimut de coucher
heureSideraleVraieLocaleCoucher = ascensionDroiteGeocentrique.Decimale + H;
heureSideraleVraieLocaleCoucher = Maths.Modulo(heureSideraleVraieLocaleCoucher, TypeAngle.ANGLE_HEURES_24);
azimutCoucher = 360.0 - azimutLever;
}
}
// ***** ALGORITHME 37 *****
/// <summary>
/// Calcule l’anomalie moyenne de la comète périodique à partir du Jour Julien des Ephémérides correspondant à la date et l’heure considérées,
/// de la distance de la comète à la Terre, du Jour Julien des Ephémérides du passage de la comète au périhélie et de la période orbitale de la comète.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
private void CalculerAnomalieMoyenne(PositionTemps a_lieuEtDateCalcul)
{
// Déclaration des variables de la méthode
double D; // variable de calcul
// Calcul du nombre de jours écoulés depuis le passage de la comète au périhélie
D = (a_lieuEtDateCalcul.JourJulienEphemerides - 0.0057755183 * r) - jourJulienEphemeridePP;
// Calcul de l'anomalie moyenne de la comète
anomalieMoyenne = new Angle((360.0 / 365.242191) * (D / periodeOrbitale), TypeAngle.ANGLE_DEGRES_360);
}
// METHODES PRIVEES
/// <summary>
/// Calcule les paramètres d'une planète pour le lieu d'observation et la date de calcul spécifié. La méthode effectue tous les calculs du synoptique
/// une seule fois sans calcul itératif de convergence pour les heures de lever et de coucher.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
/// <param name="a_terreSoleil">Objet Soleil calculé pour le lieu d'observation et la date du calcul.</param>
/// <param name="a_essai">Incrémentation de l'heure TU de 23h56min04s lorsque cet argument prend une valeur de 1 pour forcer la 2ème solution possible si l'heure TU est proche de 0h.</param>
private void CalculerNonIteratif(PositionTemps a_lieuEtDateCalcul, CorpsSystemeSolaire a_terreSoleil, int a_essai)
{
// Déclaration des variables locales de la méthode
double distanceCalculPrecedent; // variable de calcul
double precision; // variable de calcul
if (type == TypeCorpsCeleste.COMETE_PERIODIQUE) // Cas d'une comète périodique
{
do
{
// Affectation de la distance précédemment calculée à la variable distance_calcul_precedent
distanceCalculPrecedent = r;
CalculerAnomalieMoyenne(a_lieuEtDateCalcul); // Algorithme 37
CalculerAnomalieVraieEtRayonVecteur(); // Algorithme 31
CalculerCoordonneesEcliptiqueHeliocentriques(); // Algorithme 32
CalculerDistanceALaTerre(a_terreSoleil); // Algorithme 34
// Calcul de la précision sur la distance de la comète
precision = r - distanceCalculPrecedent;
}while (precision > 0.0000000001 || precision < -0.0000000001);
}
else // Cas d'une comète périodique
{
do
{
// Affectation de la distance précédemment calculée à la variable distance_calcul_precedent
distanceCalculPrecedent = r;
CalculerAnomalieVraieEtRayonVecteurParabolique(a_lieuEtDateCalcul); // Algorithme 38
CalculerCoordonneesEcliptiqueHeliocentriques(); // Algorithme 32
CalculerDistanceALaTerre(a_terreSoleil); // Algorithme 34
// Calcul de la précision sur la distance de la comète
precision = r - distanceCalculPrecedent;
}while (precision > 0.0000000001 || precision < -0.0000000001);
}
CalculerCoordonneesEcliptiquesGeocentriquesGeometriques(a_terreSoleil); // Algorithme 15
CalculerPrecessionEcliptiques(a_lieuEtDateCalcul); // Algorithme 17
CalculerCorrectionsCoordonneesEcliptiquesAberration(a_lieuEtDateCalcul, a_terreSoleil); // Algorithme 20
CalculerCoordonneesEcliptiquesGeocentriques(a_lieuEtDateCalcul, deltaLambda4, deltaBeta4, deltaLambda2, deltaBeta2); // Algorithme 22
ConvertirCoordonneesEcliptiquesVersEquatoriales(a_lieuEtDateCalcul); // Algorithme 12
ConvertirCoordonneesEquatorialesVersHorizontales(a_lieuEtDateCalcul, true); // Algorithme 13
CalculerRefractionAtmospherique(a_lieuEtDateCalcul); // Algorithme 24
ConvertirCoordonneesHorizontalesVersEquatoriales(a_lieuEtDateCalcul); // Algorithme 14
CalculerCorrectionCoordonneesEquatorialesRefraction(); // Algorithme 25
CalculerCorrectionCoordonneesEquatorialesParallaxe(a_lieuEtDateCalcul); // Algorithme 26
CalculerCoordonneesEquatorialesTopocentriques(); // Algorithme 27
ConvertirCoordonneesEquatorialesVersHorizontales(a_lieuEtDateCalcul, false); // Algorithme 13
CalculerHeuresSideralesEtAzimutsLeverCoucher(a_lieuEtDateCalcul, r, 0); // Algorithme 28
CalculerHeuresSideralesVraiesAGreenwichLeverCoucher(a_lieuEtDateCalcul); // Algorithme 7
CalculerHeuresTULeverCoucher(a_lieuEtDateCalcul, a_essai); // Algorithme 5
CalculerHeuresLocalesLeverCoucher(a_lieuEtDateCalcul); // Algorithme 2
}
// ***** ALGORITHME 19 *****
/// <summary>
/// Calcule les corrections dues à la nutation à apporter sur les coordonnées équatoriales géocentriques géométriques d’un corps céleste à partir de l’obliquité moyenne,
/// de la nutation en longitude écliptique, de la nutation en obliquité, des coordonnées équatoriales géocentriques géométriques du corps céleste à l’époque J2000,
/// des corrections dues au mouvement propre et des corrections dues à la précession.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
private void CalculerCorrectionCoordonneesEquatorialesNutation(PositionTemps a_lieuEtDateCalcul)
{
// Calcul de la correction à apporter sur l'ascension droite géométrique
deltaAlpha3 = (Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.ObliquiteMoyenne)) + Math.Sin(Maths.DegToRad(a_lieuEtDateCalcul.ObliquiteMoyenne)) * Math.Sin(Maths.DegToRad(15 * (objetCielProfond.AlphaJ2000.Decimale + deltaAlpha1 + deltaAlpha2)))
* Math.Tan(Maths.DegToRad(objetCielProfond.DeltaJ2000.Decimale + deltaDelta1 + deltaDelta2))) * (a_lieuEtDateCalcul.NutationLongitude * 3600.0)
- (Math.Cos(Maths.DegToRad(15 * (objetCielProfond.AlphaJ2000.Decimale + deltaAlpha1 + deltaAlpha2))) * Math.Tan(Maths.DegToRad(objetCielProfond.DeltaJ2000.Decimale + deltaDelta1 + deltaDelta2))) * (a_lieuEtDateCalcul.NutationObliquite * 3600.0); // correction en seconde d'arc de degrés
deltaAlpha3 = deltaAlpha3 / 54000.0; // correction en heure
// Calcul de la correction à apporter sur la déclinaison géométrique
deltaDelta3 = (Math.Sin(Maths.DegToRad(a_lieuEtDateCalcul.ObliquiteMoyenne)) * Math.Cos(Maths.DegToRad(15 * (objetCielProfond.AlphaJ2000.Decimale + deltaAlpha1 + deltaAlpha2)))) * (a_lieuEtDateCalcul.NutationLongitude * 3600.0)
+ Math.Sin(Maths.DegToRad(15 * (objetCielProfond.AlphaJ2000.Decimale + deltaAlpha1 + deltaAlpha2))) * (a_lieuEtDateCalcul.NutationObliquite * 3600.0); // correction en secondes d'arc
deltaDelta3 = deltaDelta3 / 3600.0; // correction en degrés
}
// ***** ALGORITHME 16 *****
/// <summary>
/// Calcule les corrections dues au mouvement propre d’un corps céleste à apporter sur les coordonnées équatoriales géocentriques géométriques à l’époque J2000 d’un corps céleste
/// à partir du Jour Julien des Ephémérides correspondant à la date et l’heure considérées, des mouvements propres annuels du corps céleste en ascension droite et déclinaison et
/// de la déclinaison géocentrique géométrique du corps céleste à l’époque J2000.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
private void CalculerMouvementPropre(PositionTemps a_lieuEtDateCalcul)
{
// Déclaration des variables de la méthode
double T; // variable de calcul
// Calcul du nombre d'années écoulées depuis le 1,5 janvier 2000
T = (a_lieuEtDateCalcul.JourJulienEphemerides - 2451545.0) / 365.25;
// Calcul de la correction à apporter sur l'ascension droite géocentrique géométrique à l'époque J2000
deltaAlpha1 = T * (objetCielProfond.MouvementPropreAlpha / (1000.0 * Math.Cos(Maths.DegToRad(objetCielProfond.DeltaJ2000.Decimale)))); // correction en s
deltaAlpha1 = deltaAlpha1 / 3600.0; // correction en h
// Calcul de la correction à apporter sur la déclinaison géocentrique géométrique à l'époque J2000
deltaDelta1 = T * (objetCielProfond.MouvementPropreDelta / 1000.0); // correction en s
deltaDelta1 = deltaDelta1 / 3600.0; // correction en degrés
}
// METHODES PUBLIQUES
/// <summary>
/// Calcule les paramètres de la Terre-Soleil pour le lieu d'observation et la date de calcul spécifié. La méthode effectue tous les calculs du synoptique
/// une seule fois sans calcul itératif de convergence pour les heures de lever et de coucher.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
public void CalculerNonIteratif(PositionTemps a_lieuEtDateCalcul)
{
CalculerCoordonneesEcliptiquesEtRayonVecteur(a_lieuEtDateCalcul, TypeCorpsCeleste.TERRE_SOLEIL); // Algorithme 8
ConvertirCoordonneesEcliptiquesVersEquatoriales(a_lieuEtDateCalcul); // Algorithme 12
ConvertirCoordonneesEquatorialesVersHorizontales(a_lieuEtDateCalcul, true); // Algorithme 13
CalculerRefractionAtmospherique(a_lieuEtDateCalcul); // Algorithme 24
ConvertirCoordonneesHorizontalesVersEquatoriales(a_lieuEtDateCalcul); // Algorithme 14
CalculerCorrectionCoordonneesEquatorialesRefraction(); // Algorithme 25
CalculerCorrectionCoordonneesEquatorialesParallaxe(a_lieuEtDateCalcul); // Algorithme 26
CalculerCoordonneesEquatorialesTopocentriques(); // Algorithme 27
ConvertirCoordonneesEquatorialesVersHorizontales(a_lieuEtDateCalcul, false); // Algorithme 13
CalculerTailleApparente(); // Algorithme 29
CalculerHeuresSideralesEtAzimutsLeverCoucher(a_lieuEtDateCalcul, r, taille.Decimale); // Algorithme 28
CalculerHeuresSideralesVraiesAGreenwichLeverCoucher(a_lieuEtDateCalcul); // Algorithme 7
CalculerHeuresTULeverCoucher(a_lieuEtDateCalcul, 0); // Algorithme 5
CalculerHeuresLocalesLeverCoucher(a_lieuEtDateCalcul); // Algorithme 2
}
// METHODES PRIVEES
/// <summary>
/// Calcule les paramètres d'un objet du cie profond pour le lieu d'observation et la date de calcul spécifié. La méthode effectue tous les calculs du synoptique
/// une seule fois sans calcul itératif de convergence pour les heures de lever et de coucher.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
/// <param name="a_terreSoleil">Objet Soleil calculé pour le lieu d'observation et la date du calcul.</param>
private void CalculerNonIteratif(PositionTemps a_lieuEtDateCalcul, CorpsSystemeSolaire a_terreSoleil, int a_essai)
{
CalculerMouvementPropre(a_lieuEtDateCalcul); // Algorithme 16
CalculerCorrectionCoordonneesEquatorialesPrecession(a_lieuEtDateCalcul); // Algorithme 18P
CalculerCorrectionCoordonneesEquatorialesNutation(a_lieuEtDateCalcul); // Algorithme 19
CalculerCorrectionCoordonneesEquatorialesAberration(a_lieuEtDateCalcul, a_terreSoleil); // Algorithme 21
CalculerCoordonneesEquatorialesGeocentriques(); // Algorithme 23
ConvertirCoordonneesEquatorialesVersHorizontales(a_lieuEtDateCalcul, true); // Algorithme 13
CalculerRefractionAtmospherique(a_lieuEtDateCalcul); // Algorithme 24
ConvertirCoordonneesHorizontalesVersEquatoriales(a_lieuEtDateCalcul); // Algorithme 14
ConvertirCoordonneesEquatorialesVersHorizontales(a_lieuEtDateCalcul, false); // Algorithme 13
CalculerMagnitudeApparente(); // Algorithme 39
CalculerHeuresSideralesEtAzimutsLeverCoucher(a_lieuEtDateCalcul); // Algorithme 28
CalculerHeuresSideralesVraiesAGreenwichLeverCoucher(a_lieuEtDateCalcul); // Algorithme 7
CalculerHeuresTULeverCoucher(a_lieuEtDateCalcul, a_essai); // Algorithme 5
CalculerHeuresLocalesLeverCoucher(a_lieuEtDateCalcul); // Algorithme 2
}
// METHODES PRIVEES
/// <summary>
/// Calcule les paramètres de la Lune pour le lieu d'observation et la date de calcul spécifié. La méthode effectue tous les calculs du synoptique
/// une seule fois sans calcul itératif de convergence pour les heures de lever et de coucher.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
/// <param name="a_terreSoleil">Objet Soleil calculé pour le lieu d'observation et la date du calcul.</param>
/// <param name="a_essai">Incrémentation de l'heure TU de 23h56min04s lorsque cet argument prend une valeur de 1 pour forcer la 2ème solution possible si l'heure TU est proche de 0h.</param>
public void CalculerNonIteratif(PositionTemps a_lieuEtDateCalcul, CorpsSystemeSolaire a_terreSoleil, int a_essai)
{
CalculerCoordoonneesEcliptiquesEtRayonVecteur(a_lieuEtDateCalcul); // Algorithme 40
ConvertirCoordonneesEcliptiquesVersEquatoriales(a_lieuEtDateCalcul); // Algorithme 12
ConvertirCoordonneesEquatorialesVersHorizontales(a_lieuEtDateCalcul, true); // Algorithme 13
CalculerRefractionAtmospherique(a_lieuEtDateCalcul); // Algorithme 24
ConvertirCoordonneesHorizontalesVersEquatoriales(a_lieuEtDateCalcul); // Algorithme 14
CalculerCorrectionCoordonneesEquatorialesRefraction(); // Algorithme 25
CalculerCorrectionCoordonneesEquatorialesParallaxe(a_lieuEtDateCalcul); // Algorithme 26
CalculerCoordonneesEquatorialesTopocentriques(); // Algorithme 27
ConvertirCoordonneesEquatorialesVersHorizontales(a_lieuEtDateCalcul, false); // Algorithme 13
CalculerPhaseEtTailleApparenteLune(a_terreSoleil); // Algorithme 41
CalculerHeuresSideralesEtAzimutsLeverCoucher(a_lieuEtDateCalcul, r, taille.Decimale); // Algorithme 28
CalculerHeuresSideralesVraiesAGreenwichLeverCoucher(a_lieuEtDateCalcul); // Algorithme 7
CalculerHeuresTULeverCoucher(a_lieuEtDateCalcul, 0); // Algorithme 5
CalculerHeuresLocalesLeverCoucher(a_lieuEtDateCalcul); // Algorithme 2
}
// Algorithme 20
/// <summary>
/// Calcule les corrections dues à l’aberration de la lumière à apporter sur les coordonnées écliptiques géocentriques géométriques d’une planète
/// ou d’une comète à partir du Jour Julien des Ephémérides, de la longitude écliptique géocentrique géométrique du Soleil et des coordonnées écliptiques
/// géocentriques géométriques de la planète ou de la comète.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
/// <param name="a_terreSoleil">Objet représentant la Terre/le Soleil.</param>
private void CalculerCorrectionsCoordonneesEcliptiquesAberration(PositionTemps a_lieuEtDateCalcul, CorpsSystemeSolaire a_terreSoleil)
{
// Déclaration des variables de la méthode
double T, et, pit; // variables de calcul
// Calcul du nombre de siècles depuis le 1,5 janvier 2000
T = (a_lieuEtDateCalcul.JourJulienEphemerides - 2451545.0) / 36525.0;
// Calcul de l'excentricité de l'orbite de la Terre
et = 0.016708617 - 0.000042037 * T - 0.0000001236 * T * T + 0.00000000004 * T * T * T;
// Calcul de la longitude du perihélie de la Terre
pit = 102.937348 + 1.7195269 * T + 0.00045962 * T * T + 0.000000499 * T * T * T;
// Calcul de la correction à apporter sur la longitude écliptique géocentrique géométrique de la planète ou de la comète
deltaLambda4 = (-20.49552 * Math.Cos(Maths.DegToRad(a_terreSoleil.LambdaGeometrique - lambdaGeometrique)) + 20.49552 * et * Math.Cos(Maths.DegToRad(pit - lambdaGeometrique))) / Math.Cos(Maths.DegToRad(betaGeometrique));
// Calcul de la correction à apporter sur la latitude écliptique géocentrique géométrique de la planète ou de la comète
deltaBeta4 = -20.49552 * Math.Sin(Maths.DegToRad(betaGeometrique)) * (Math.Sin(Maths.DegToRad(a_terreSoleil.LambdaGeometrique - lambdaGeometrique)) - et * Math.Sin(Maths.DegToRad(pit - lambdaGeometrique)));
deltaBeta4 /= 3600.0;
}
// Algorithme 12
/// <summary>
/// Calcule les coordonnées écliptiques géocentriques d’un corps céleste en coordonnées équatoriales géocentriques à partir de l’obliquité moyenne et de la nutation en obliquité.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
protected void ConvertirCoordonneesEcliptiquesVersEquatoriales(PositionTemps a_lieuEtDateCalcul)
{
// Déclaration des variables de la méthode
double x, y; // variables de calcul
// Calcul de la déclinaison géocentrique
double declGeo = Math.Asin((Math.Sin(Maths.DegToRad(beta.Decimale)) * Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.ObliquiteMoyenne + a_lieuEtDateCalcul.NutationObliquite)))
+ (Math.Cos(Maths.DegToRad(beta.Decimale)) * Math.Sin(Maths.DegToRad(a_lieuEtDateCalcul.ObliquiteMoyenne + a_lieuEtDateCalcul.NutationObliquite)) * Math.Sin(Maths.DegToRad(lambda.Decimale))));
declGeo = Maths.RadToDeg(declGeo);
declinaisonGeocentrique = new Angle(declGeo, TypeAngle.ANGLE_DEGRES_90);
// Calcul de l'ascension droite géocentrique
y = (Math.Sin(Maths.DegToRad(lambda.Decimale)) * Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.ObliquiteMoyenne + a_lieuEtDateCalcul.NutationObliquite))) - (Math.Tan(Maths.DegToRad(beta.Decimale)) * Math.Sin(Maths.DegToRad(a_lieuEtDateCalcul.ObliquiteMoyenne + a_lieuEtDateCalcul.NutationObliquite)));
x = Math.Cos(Maths.DegToRad(lambda.Decimale));
double alphaGeo = Math.Atan2(y, x);
alphaGeo = Maths.RadToDeg(alphaGeo);
alphaGeo = Maths.Modulo(alphaGeo, TypeAngle.ANGLE_DEGRES_360) / 15.0;
ascensionDroiteGeocentrique = new Angle(alphaGeo, TypeAngle.ANGLE_HEURES_24);
}
// Algorithme 24
/// <summary>
/// Calcule la correction due à la réfraction atmosphérique à apporter sur l’altitude géocentrique d’un corps céleste à partir de l’altitude géocentrique, de la pression
/// et de la température ambiante du lieu d’observation. En cas de non disponibilité de ces données, des valeurs par défaut (1013mbar pour la pression et 10°C pour la température)
/// sont utilisées.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
protected void CalculerRefractionAtmospherique(PositionTemps a_lieuEtDateCalcul)
{
// Déclaration des variables de la méthode
double z, R = 0.0; // variables de calcul
// Calcul de l'angle au zénith
z = 90.0 - altitudeGeocentrique.Decimale;
// Calcul de la réfraction atmosphérique
if (altitudeGeocentrique.Decimale >= 15.0)
{
R = (0.00452 * (double)a_lieuEtDateCalcul.LieuObservation.Pression * Math.Tan(Maths.DegToRad(z))) / (273.0 + (double)a_lieuEtDateCalcul.LieuObservation.Temperature);
}
else
{
R = (a_lieuEtDateCalcul.LieuObservation.Pression * (0.1594 + 0.0196 * altitudeGeocentrique.Decimale + 0.00002 * altitudeGeocentrique.Decimale * altitudeGeocentrique.Decimale))
/ ((273.0 + (double)a_lieuEtDateCalcul.LieuObservation.Temperature) * (1 + 0.505 * altitudeGeocentrique.Decimale + 0.0845 * altitudeGeocentrique.Decimale * altitudeGeocentrique.Decimale));
}
// Calcul de l'altitude topocentrique corrigée de la réfraction atmosphérique
altitudeTopocentrique = new Angle(altitudeGeocentrique.Decimale + R, TypeAngle.ANGLE_DEGRES_90);
azimutTopocentrique = new Angle(azimutGeocentrique.Decimale, TypeAngle.ANGLE_DEGRES_360);
}
// ***** ALGORITHME 21 *****
/// <summary>
/// Calcule les corrections dues à l’aberration de la lumière à apporter sur les coordonnées équatoriales géocentriques géométriques d’un corps céleste à partir du Jour Julien des Ephémérides correspondant
/// à la date et l’heure considérées, de la longitude écliptique géocentrique géométrique du Soleil, de l’obliquité moyenne, de la nutation en obliquité, des coordonnées équatoriales géocentriques
/// géométriques du corps céleste à l’époque J2000, des corrections dues au mouvement propre et des corrections dues à la précession.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
/// <param name="a_terreSoleil">Objet Soleil calculé pour le lieu d'observation et la date du calcul.</param>
private void CalculerCorrectionCoordonneesEquatorialesAberration(PositionTemps a_lieuEtDateCalcul, CorpsSystemeSolaire a_terreSoleil)
{
// Déclaration des variables de la méthode
double T, et, pit; // variables de calcul
// Calcul du nombre de siècles depuis le 1,5 janvier 2000
T = (a_lieuEtDateCalcul.JourJulienEphemerides - 2451545.0) / 36525.0;
// Calcul de l'excentricité de l'orbite de la Terre
et = 0.016708617 - 0.000042037 * T - 0.0000001236 * T * T + 0.00000000004 * T * T * T;
// Calcul de la longitude du perihélie de la Terre
pit = 102.937348 + 1.7195269 * T + 0.00045962 * T * T + 0.000000499 * T * T * T;
// Calcul de la correction à apporter sur la longitude écliptique géocentrique géométrique
deltaAlpha4 = -20.49552 * ((Math.Cos(Maths.DegToRad(15 * (objetCielProfond.AlphaJ2000.Decimale + deltaAlpha1 + deltaAlpha2))) * Math.Cos(Maths.DegToRad(a_terreSoleil.LambdaGeometrique))
* Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.ObliquiteMoyenne + a_lieuEtDateCalcul.NutationObliquite)) + Math.Sin(Maths.DegToRad(15 * (objetCielProfond.AlphaJ2000.Decimale + deltaAlpha1 + deltaAlpha2)))
* Math.Sin(Maths.DegToRad(a_terreSoleil.LambdaGeometrique))) / Math.Cos(Maths.DegToRad(objetCielProfond.DeltaJ2000.Decimale + deltaDelta1 + deltaDelta2)))
+ 20.49552 * et * ((Math.Cos(Maths.DegToRad(15 * (objetCielProfond.AlphaJ2000.Decimale + deltaAlpha1 + deltaAlpha2))) * Math.Cos(Maths.DegToRad(pit))
* Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.ObliquiteMoyenne + a_lieuEtDateCalcul.NutationObliquite)) + Math.Sin(Maths.DegToRad(15 * (objetCielProfond.AlphaJ2000.Decimale + deltaAlpha1 + deltaAlpha2))) * Math.Sin(Maths.DegToRad(pit)))
/ Math.Cos(Maths.DegToRad(objetCielProfond.DeltaJ2000.Decimale + deltaDelta1 + deltaDelta2)));
deltaAlpha4 = deltaAlpha4 / 54000.0; // corrections en heure
// Calcul de la correction à apporter sur la déclinaison géocentrique géométrique
deltaDelta4 = -20.49552 * (Math.Cos(Maths.DegToRad(a_terreSoleil.LambdaGeometrique)) * Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.ObliquiteMoyenne + a_lieuEtDateCalcul.NutationObliquite)) * (Math.Tan(Maths.DegToRad(a_lieuEtDateCalcul.ObliquiteMoyenne + a_lieuEtDateCalcul.NutationObliquite))
* Math.Cos(Maths.DegToRad(objetCielProfond.DeltaJ2000.Decimale + deltaDelta1 + deltaDelta2)) - Math.Sin(Maths.DegToRad(15 * (objetCielProfond.AlphaJ2000.Decimale + deltaAlpha1 + deltaAlpha2)))
* Math.Sin(Maths.DegToRad(objetCielProfond.DeltaJ2000.Decimale + deltaDelta1 + deltaDelta2))) + Math.Cos(Maths.DegToRad(15 * (objetCielProfond.AlphaJ2000.Decimale + deltaAlpha1 + deltaAlpha2)))
* Math.Sin(Maths.DegToRad(objetCielProfond.DeltaJ2000.Decimale + deltaDelta1 + deltaDelta2)) * Math.Sin(Maths.DegToRad(a_terreSoleil.LambdaGeometrique)))
+ 20.49552 * et * (Math.Cos(Maths.DegToRad(pit)) * Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.ObliquiteMoyenne + a_lieuEtDateCalcul.NutationObliquite)) * (Math.Tan(Maths.DegToRad(a_lieuEtDateCalcul.ObliquiteMoyenne + a_lieuEtDateCalcul.NutationObliquite))
* Math.Cos(Maths.DegToRad(objetCielProfond.DeltaJ2000.Decimale + deltaDelta1 + deltaDelta2)) - Math.Sin(Maths.DegToRad(15 * (objetCielProfond.AlphaJ2000.Decimale + deltaAlpha1 + deltaAlpha2)))
* Math.Sin(Maths.DegToRad(objetCielProfond.DeltaJ2000.Decimale + deltaDelta1 + deltaDelta2))) + Math.Cos(Maths.DegToRad(15 * (objetCielProfond.AlphaJ2000.Decimale + deltaAlpha1 + deltaAlpha2)))
* Math.Sin(Maths.DegToRad(objetCielProfond.DeltaJ2000.Decimale + deltaDelta1 + deltaDelta2)) * Math.Sin(Maths.DegToRad(pit))); // correction en secondes d'arc
deltaDelta4 = deltaDelta4 / 3600.0; // corrections en degrés
}
// METHODES PUBLIQUES
//Aucune
// METHODES PROTEGEES
// Algorithme 2
/// <summary>
/// Calcule l’heure locale du point d’observation à partir de la date et de l’heure à Greenwich, c’est-à-dire la date
/// et l’heure TU, et du décalage horaire dû au fuseau horaire (en France +1h) et aux économies d’énergie liées
/// à l’heure d’été et à l’heure d’hiver (en France +1h en été et 0h en hiver).
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
protected void CalculerHeuresLocalesLeverCoucher(PositionTemps a_lieuEtDateCalcul)
{
// Calcul de l'heure locale de lever
double heureCalculee = heureTULever + (double)a_lieuEtDateCalcul.ZoneHoraire + (double)a_lieuEtDateCalcul.ChangementHeure;
heureCalculee = Maths.Modulo(heureCalculee, TypeAngle.ANGLE_HEURES_24);
int nombreHeure = (int)heureCalculee;
int nombreMinute = (int)Math.Round((60.0 * (heureCalculee - (double)nombreHeure)), 0);
if (nombreMinute == 60)
{
nombreMinute = 0;
nombreHeure += 1;
if (nombreHeure == 24)
{
nombreHeure = 0;
}
}
heureLocaleLever = new DateTime(a_lieuEtDateCalcul.HeureLocale.Year, a_lieuEtDateCalcul.HeureLocale.Month, a_lieuEtDateCalcul.HeureLocale.Day, nombreHeure, nombreMinute, 0);
// Calcul de l'heure locale de coucher
heureCalculee = heureTUCoucher + (double)a_lieuEtDateCalcul.ZoneHoraire + (double)a_lieuEtDateCalcul.ChangementHeure;
heureCalculee = Maths.Modulo(heureCalculee, TypeAngle.ANGLE_HEURES_24);
nombreHeure = (int)heureCalculee;
nombreMinute = (int)Math.Round((60.0 * (heureCalculee - (double)nombreHeure)), 0);
if (nombreMinute == 60)
{
nombreMinute = 0;
nombreHeure += 1;
if (nombreHeure == 24)
{
nombreHeure = 0;
}
}
heureLocaleCoucher = new DateTime(a_lieuEtDateCalcul.HeureLocale.Year, a_lieuEtDateCalcul.HeureLocale.Month, a_lieuEtDateCalcul.HeureLocale.Day, nombreHeure, nombreMinute, 0);
}
// Méthode surchargée
/// <summary>
/// Calcule les heures sidérales vraies et les azimuts topocentriques de lever et de coucher d’un corps céleste à partir des coordonnées équatoriales géocentriques, de la latitude du lieu d’observation.
/// Le calcul par cette version surchargée ne tient pas compte de la distance à la Terre et de la taille apparente (cas des corps du système solaire).
/// Pour prendre en compte la distance à la Terre et la taille apparente, utiliser la version surchargée avec ces paramètres en argument.
/// </summary>
/// <param name="a_lieuEtDateCalcul"></param>
protected void CalculerHeuresSideralesEtAzimutsLeverCoucher(PositionTemps a_lieuEtDateCalcul)
{
CalculerHeuresSideralesEtAzimutsLeverCoucher(a_lieuEtDateCalcul, double.MaxValue, 0.0);
}
// ***** ALGORITHME 40P *****
private void CalculerCoordoonneesEcliptiquesEtRayonVecteur(PositionTemps a_lieuEtDateCalcul)
{
// Déclaration des variables de la méthode
double T, ll, Dl, Ms, Ml, Fl, A1, A2, A3, e; // variable de calcul
int i; // variable de comptage pour les boucles de calcul
double argument, somme_l = 0.0, somme_b = 0.0, somme_r = 0.0; // variable de calcul
// Calcul du nombre de siècles écoulés depuis le 1,5 janvier 2000
T = (a_lieuEtDateCalcul.JourJulienEphemerides - 2451545.0) / 36525.0;
// Calcul de la longitude moyenne de la Lune ll
ll = 218.316654361 + 481267.88134240 * T - 0.00132675 * T * T + (1 / 538841) * T * T * T - (1 / 65193770) * T * T * T * T;
ll = Maths.Modulo(ll, TypeAngle.ANGLE_DEGRES_360);
// Calcul de l'élongation moyenne de la Lune Dl
Dl = 297.85020420 + 445267.11151675 * T - 0.001630028 * T * T + (1 / 545868) * T * T * T - (1 / 113065327) * T * T * T * T;
Dl = Maths.Modulo(Dl, TypeAngle.ANGLE_DEGRES_360);
// Calcul de l'anomalie moyenne du Soleil Ms
Ms = 357.52910918 + 35999.05029094 * T - 0.000153583 * T * T + (1 / 24489796) * T * T * T;
Ms = Maths.Modulo(Ms, TypeAngle.ANGLE_DEGRES_360);
// Calcul de l'anomalie moyenne de la Lune Ml
Ml = 134.96341138 + 477198.86763133 * T + 0.008997028 * T * T + (1 / 69699) * T * T * T - (1 / 14711892) * T * T * T * T;
Ml = Maths.Modulo(Ml, TypeAngle.ANGLE_DEGRES_360);
// Calcul de l'argument de la latitude moyenne de la Lune Fl
Fl = 93.27209932 + 483202.01752731 * T - 0.003402917 * T * T - (1 / 3525955) * T * T * T + (1 / 863309353) * T * T * T * T;
Fl = Maths.Modulo(Fl, TypeAngle.ANGLE_DEGRES_360);
// Calcul du paramètre correcteur A1 dû à Vénus
A1 = 119.75 + 131.849 * T;
A1 = Maths.Modulo(A1, TypeAngle.ANGLE_DEGRES_360);
// Calcul du paramètre correcteur A2 dû à Jupiter
A2 = 53.09 + 479264.290 * T;
A2 = Maths.Modulo(A2, TypeAngle.ANGLE_DEGRES_360);
// Calcul du paramètre correcteur additionnel A3
A3 = 313.45 + 481266.484 * T;
A3 = Maths.Modulo(A3, TypeAngle.ANGLE_DEGRES_360);
// Calcul du paramètre correcteur e dû à l'excentricité de la Terre
e = 1 - 0.002516 * T - 0.0000074 * T * T;
// Calcul de la longitude écliptique géométrique et géocentrique de la Lune
for (i = 0; i < ELP2000_82B_BP.INDEX_MAX_COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP; i++)
{
argument = Maths.DegToRad(ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 0] * Dl + ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 1] * Ms + ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 2] * Ml + ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 3] * Fl);
if (ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 1] == 0)
{
somme_l += ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 4] * Math.Sin(argument);
}
if (ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 1] == -1 || ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 1] == 1)
{
somme_l += ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 4] * e *Math.Sin(argument);
}
if (ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 1] == -2 || ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 1] == 2)
{
somme_l += ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 4] * e *e *Math.Sin(argument);
}
}
somme_l += 3958 * Math.Sin(Maths.DegToRad(A1)) + 1962 * Math.Sin(Maths.DegToRad(ll - Fl)) + 318 * Math.Sin(Maths.DegToRad(A2));
lambdaGeometrique = ll + (somme_l / 1000000.0);
lambdaGeometrique = Maths.Modulo(lambdaGeometrique, TypeAngle.ANGLE_DEGRES_360);
lambda = new Angle((lambdaGeometrique + a_lieuEtDateCalcul.NutationLongitude), TypeAngle.ANGLE_DEGRES_360);
// Calcul de la latitude écliptique géométrique et géocentrique de la Lune
for (i = 0; i < ELP2000_82B_BP.INDEX_MAX_COEFFICIENT_LATITUDE_LUNE_BP; i++)
{
argument = Maths.DegToRad(ELP2000_82B_BP.COEFFICIENT_LATITUDE_LUNE_BP[i, 0] * Dl + ELP2000_82B_BP.COEFFICIENT_LATITUDE_LUNE_BP[i, 1] * Ms + ELP2000_82B_BP.COEFFICIENT_LATITUDE_LUNE_BP[i, 2] * Ml + ELP2000_82B_BP.COEFFICIENT_LATITUDE_LUNE_BP[i, 3] * Fl);
if (ELP2000_82B_BP.COEFFICIENT_LATITUDE_LUNE_BP[i, 1] == 0)
{
somme_b += ELP2000_82B_BP.COEFFICIENT_LATITUDE_LUNE_BP[i, 4] * Math.Sin(argument);
}
if (ELP2000_82B_BP.COEFFICIENT_LATITUDE_LUNE_BP[i, 1] == -1 || ELP2000_82B_BP.COEFFICIENT_LATITUDE_LUNE_BP[i, 1] == 1)
{
somme_b += ELP2000_82B_BP.COEFFICIENT_LATITUDE_LUNE_BP[i, 4] * e *Math.Sin(argument);
}
if (ELP2000_82B_BP.COEFFICIENT_LATITUDE_LUNE_BP[i, 1] == -2 || ELP2000_82B_BP.COEFFICIENT_LATITUDE_LUNE_BP[i, 1] == 2)
{
somme_b += ELP2000_82B_BP.COEFFICIENT_LATITUDE_LUNE_BP[i, 4] * e *e *Math.Sin(argument);
}
}
somme_b += -2235 * Math.Sin(Maths.DegToRad(ll)) + 382 * Math.Sin(Maths.DegToRad(A3)) + 175 * Math.Sin(Maths.DegToRad(A1 - Fl)) + 127 * Math.Sin(Maths.DegToRad(ll - Ml)) - 115 * Math.Sin(Maths.DegToRad(ll + Ml));
betaGeometrique = (somme_b / 1000000.0);
beta = new Angle(betaGeometrique, TypeAngle.ANGLE_DEGRES_90);
// Calcul du rayon vecteur de la Lune
for (i = 0; i < ELP2000_82B_BP.INDEX_MAX_COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP; i++)
{
argument = Maths.DegToRad(ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 0] * Dl + ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 1] * Ms + ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 2] * Ml + ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 3] * Fl);
if (ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 1] == 0)
{
somme_r += ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 5] * Math.Cos(argument);
}
if (ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 1] == -1 || ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 1] == 1)
{
somme_r += ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 5] * e *Math.Cos(argument);
}
if (ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 1] == -2 || ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 1] == 2)
{
somme_r += ELP2000_82B_BP.COEFFICIENT_LONGITUDE_RAYON_VECTEUR_LUNE_BP[i, 5] * e *e *Math.Cos(argument);
}
}
r = 385000.56 + (somme_r / 1000.0);
}
// Algorithme 13
/// <summary>
/// Calcule les coordonnées équatoriales (géocentriques ou topocentriques) d’un corps céleste en coordonnées horizontales (géocentriques ou topocentriques)
/// à partir de la latitude et de l’heure sidérale locale.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
/// <param name="a_geocentriqueOuTopocentrique">Type de coordonnées à convertir : géocentriques (true) ou topocentriques (false).</param>
protected void ConvertirCoordonneesEquatorialesVersHorizontales(PositionTemps a_lieuEtDateCalcul, bool a_geocentriqueOuTopocentrique)
{
// Déclaration des variables de la méthode
double H; // variable de calcul
// Cas des coordonnées équatoriales géocentriques
if (a_geocentriqueOuTopocentrique)
{
// Calcul de l'angle horaire H
H = Maths.CalculerHeureDecimale(a_lieuEtDateCalcul.HeureSideraleLocale) - ascensionDroiteGeocentrique.Decimale;
H = Maths.Modulo(H, TypeAngle.ANGLE_HEURES_24); // H ramené dans l'intervalle [0h ; 24h]
H = 15.0 * H; // Conversion de H en degrés
// Calcul de l'altitude géocentrique
double altGeo = Math.Asin(Math.Sin(Maths.DegToRad(declinaisonGeocentrique.Decimale)) * Math.Sin(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale))
+ Math.Cos(Maths.DegToRad(declinaisonGeocentrique.Decimale)) * Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale)) * Math.Cos(Maths.DegToRad(H)));
altGeo = Maths.RadToDeg(altGeo); // Conversion de radians en degrées
altitudeGeocentrique = new Angle(altGeo, TypeAngle.ANGLE_DEGRES_90);
// Calcul de l'azimut géocentrique
if (Math.Sin(Maths.DegToRad(H)) <= 0.0)
{
double azgeo = Math.Acos((Math.Sin(Maths.DegToRad(declinaisonGeocentrique.Decimale)) - Math.Sin(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale))
* Math.Sin(Maths.DegToRad(altitudeGeocentrique.Decimale))) / (Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale)) * Math.Cos(Maths.DegToRad(altitudeGeocentrique.Decimale))));
azgeo = Maths.RadToDeg(azgeo);
azimutGeocentrique = new Angle(azgeo, TypeAngle.ANGLE_DEGRES_360);
}
if (Math.Sin(Maths.DegToRad(H)) > 0.0)
{
double azGeo = Math.Acos((Math.Sin(Maths.DegToRad(declinaisonGeocentrique.Decimale)) - Math.Sin(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale)) * Math.Sin(Maths.DegToRad(altitudeGeocentrique.Decimale)))
/ (Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale)) * Math.Cos(Maths.DegToRad(altitudeGeocentrique.Decimale))));
azGeo = 360 - Maths.RadToDeg(azGeo);
azimutGeocentrique = new Angle(azGeo, TypeAngle.ANGLE_DEGRES_360);
}
}
// Cas des coordonnées équatoriales topocentriques
else
{
// Calcul de l'angle horaire H
H = Maths.CalculerHeureDecimale(a_lieuEtDateCalcul.HeureSideraleLocale) - AscensionDroiteTopocentrique.Decimale;
H = Maths.Modulo(H, TypeAngle.ANGLE_HEURES_24); // H ramené dans l'intervalle [0h ; 24h]
H = 15.0 * H; // Conversion de H en degrés
// Calcul de l'altitude topocentrique
double altTop = Math.Asin((Math.Sin(Maths.DegToRad(declinaisonTopocentrique.Decimale)) * Math.Sin(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale)))
+ (Math.Cos(Maths.DegToRad(declinaisonTopocentrique.Decimale)) * Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale)) * Math.Cos(Maths.DegToRad(H))));
altTop = Maths.RadToDeg(altTop); // Conversion de radians en degrées
altitudeTopocentrique = new Angle(altTop, TypeAngle.ANGLE_DEGRES_90);
// Calcul de l'azimut topocentrique
if (Math.Sin(Maths.DegToRad(H)) <= 0.0)
{
double azTop = Math.Acos((Math.Sin(Maths.DegToRad(declinaisonTopocentrique.Decimale)) - Math.Sin(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale))
* Math.Sin(Maths.DegToRad(altitudeTopocentrique.Decimale))) / (Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale)) * Math.Cos(Maths.DegToRad(altitudeTopocentrique.Decimale))));
azTop = Maths.RadToDeg(azTop);
azimutTopocentrique = new Angle(azTop, TypeAngle.ANGLE_DEGRES_360);
}
if (Math.Sin(Maths.DegToRad(H)) > 0.0)
{
double azTop = Math.Acos((Math.Sin(Maths.DegToRad(declinaisonTopocentrique.Decimale)) - Math.Sin(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale)) * Math.Sin(Maths.DegToRad(altitudeTopocentrique.Decimale)))
/ (Math.Cos(Maths.DegToRad(a_lieuEtDateCalcul.LieuObservation.Latitude.Decimale)) * Math.Cos(Maths.DegToRad(altitudeTopocentrique.Decimale))));
azTop = 360.0 - Maths.RadToDeg(azTop);
azimutTopocentrique = new Angle(azTop, TypeAngle.ANGLE_DEGRES_360);
}
}
}
// Algorithme 35
/// <summary>
/// Calcule la taille apparente, la phase et la magnitude apparente des planètes à partir de la distance des planètes à la Terre,
/// du rayon vecteur des planètes, de la taille apparente des planètes à 1 UA, de l’altitude topocentrique des planètes et du
/// rayon vecteur de la Terre.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
/// <param name="a_terreSoleil">Objet représentant la Terre/le Soleil.</param>
private void CalculerTaillePhaseMagnitude(PositionTemps a_lieuEtDateCalcul, CorpsSystemeSolaire a_terreSoleil)
{
// Déclaration des variables de la méthode
double i, z; // variable de calcul
double[] taille_1UA = { 6.72, 16.82, 9.36, 196.88, 165.40, 70.04, 67.00 }; // taille apparente des planètes à 1 UA
// Calcul de l'angle de phase (en radians)
i = Math.Acos((rSoleil * rSoleil + r * r - a_terreSoleil.R * a_terreSoleil.R) / (2 * rSoleil * r));
// Calcul de la phase
phase = (1 + Math.Cos(i)) / 2;
// Conversion de l'angle de phase en degrés
i = Maths.RadToDeg(i);
// Cas de Mercure
if (type == TypeCorpsCeleste.MERCURE)
{
taille = new Angle((float)(taille_1UA[0] / r) / 3600, TypeAngle.ANGLE_DEGRES_360);
//taille = new Angle(0, 0, (float)(taille_1UA[0] / r), TypeAngle.ANGLE_DEGRES_360);
magnitude = -0.42 + 5 * Math.Log10(rSoleil * r) + 0.0380 * i - 0.000273 * i * i + 0.000002 * i * i * i;
}
// Cas de Vénus
if (type == TypeCorpsCeleste.VENUS)
{
taille = new Angle((float)(taille_1UA[1] / r) / 3600, TypeAngle.ANGLE_DEGRES_360);
//taille = new Angle(0, 0, (float)(taille_1UA[1] / r), TypeAngle.ANGLE_DEGRES_360);
magnitude = -4.40 + 5 * Math.Log10(rSoleil * r) + 0.0009 * i + 0.000239 * i * i - 0.00000065 * i * i * i;
}
// Cas de Mars
if (type == TypeCorpsCeleste.MARS)
{
taille = new Angle((float)(taille_1UA[2] / r) / 3600, TypeAngle.ANGLE_DEGRES_360);
//taille = new Angle(0, 0, (float)(taille_1UA[2] / r), TypeAngle.ANGLE_DEGRES_360);
magnitude = -1.52 + 5 * Math.Log10(rSoleil * r) + 0.016 * i;
}
// Cas de Jupiter
if (type == TypeCorpsCeleste.JUPITER)
{
taille = new Angle((float)(taille_1UA[3] / r) / 3600, TypeAngle.ANGLE_DEGRES_360);
//taille = new Angle(0, 0, (float)(taille_1UA[3] / r), TypeAngle.ANGLE_DEGRES_360);
magnitude = -9.40 + 5 * Math.Log10(rSoleil * r) + 0.005 * i;
}
// Cas de Saturne
if (type == TypeCorpsCeleste.SATURNE)
{
taille = new Angle((float)(taille_1UA[4] / r) / 3600, TypeAngle.ANGLE_DEGRES_360);
//taille = new Angle(0, 0, (float)(taille_1UA[4] / r), TypeAngle.ANGLE_DEGRES_360);
magnitude = -8.88 + 5 * Math.Log10(rSoleil * r) + 0.044 * i;
}
// Cas de Uranus
if (type == TypeCorpsCeleste.URANUS)
{
taille = new Angle((float)(taille_1UA[5] / r) / 3600, TypeAngle.ANGLE_DEGRES_360);
//taille = new Angle(0, 0, (float)(taille_1UA[5] / r), TypeAngle.ANGLE_DEGRES_360);
magnitude = -7.19 + 5 * Math.Log10(rSoleil * r);
}
// Cas de Neptune
if (type == TypeCorpsCeleste.NEPTUNE)
{
taille = new Angle((float)(taille_1UA[6] / r) / 3600, TypeAngle.ANGLE_DEGRES_360);
//taille = new Angle(0, 0, (float)(taille_1UA[6] / r), TypeAngle.ANGLE_DEGRES_360);
magnitude = -6.87 + 5 * Math.Log10(rSoleil * r);
}
// Calcul de la baisse de magnitude due à l'extinction atmosphérique
z = 90.0 - altitudeTopocentrique.Decimale;
deltaMagnitude = 0.2 / Math.Cos(Maths.DegToRad(z));
}
/// <summary>
/// Calcule les paramètres d'une planète pour le lieu d'observation et la date de calcul spécifié. La méthode effectue tous les calculs du synoptique
/// une seule fois sans calcul itératif de convergence pour les heures de lever et de coucher.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
/// <param name="a_terreSoleil">Objet Soleil calculé pour le lieu d'observation et la date du calcul.</param>
public void CalculerNonIteratif(PositionTemps a_lieuEtDateCalcul, CorpsSystemeSolaire a_terreSoleil)
{
CalculerNonIteratif(a_lieuEtDateCalcul, a_terreSoleil, 0);
}
/// <summary>
/// Calcule les paramètres de la Terre-Soleil pour le lieu d'observation et la date de calcul spécifié. La méthode effectue tous les calculs du synoptique
/// de façon itérative jusqu'à convergence des heures de lever et de coucher.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
public void CalculerIteratif(PositionTemps a_lieuEtDateCalcul)
{
// Déclaration des variables de la méthode
double heureSideraleVraieLocaleLever; // Heure sidérale vraie locale de lever
double azimutLever; // Azimut de lever
double heureSideraleVraieLocaleCoucher; // Heure sidérale vraie locale de coucher
double azimutCoucher; // Azimut de coucher
double heureSideraleVraieAGreenwichLever; // Heure sidérale vraie à Greenwich de lever
double heureSideraleVraieAGreenwichCoucher; // Heure sidérale vraie à Greenwich de coucher
double heureTULever; // Heure TU de lever
double heureTUCoucher; // Heure TU de coucher
DateTime heureLocaleLever = new DateTime(); // Heure locale de lever
DateTime heureLocaleCoucher = new DateTime(); // Heure locale de coucher
TimeSpan precision = new TimeSpan(); // variable de contrôle de la convergence
PositionTemps dateTemporaireCalcul = null; // Objet PositionTemps pour le calcul en temps différé
// Calcul initial des paramètres du Soleil
CalculerNonIteratif(a_lieuEtDateCalcul);
// Sauvegarde des heures de lever et de coucher
heureSideraleVraieLocaleLever = this.heureSideraleVraieLocaleLever;
azimutLever = this.azimutLever;
heureSideraleVraieLocaleCoucher = this.heureSideraleVraieLocaleCoucher;
azimutCoucher = this.azimutCoucher;
heureSideraleVraieAGreenwichLever = this.heureSideraleVraieAGreenwichLever;
heureSideraleVraieAGreenwichCoucher = this.heureSideraleVraieAGreenwichCoucher;
heureTULever = this.heureTULever;
heureTUCoucher = this.heureTUCoucher;
heureLocaleLever = this.heureLocaleLever;
heureLocaleCoucher = this.heureLocaleCoucher;
// Création et initialisation d'un nouvel objet PositionTemps pour calculer les heures de lever et de coucher en temps différé
dateTemporaireCalcul = new PositionTemps(a_lieuEtDateCalcul.LieuObservation, a_lieuEtDateCalcul.HeureLocale.Year, a_lieuEtDateCalcul.HeureLocale.Month, a_lieuEtDateCalcul.HeureLocale.Day, heureLocaleLever.Hour, heureLocaleLever.Minute, 0, a_lieuEtDateCalcul.ZoneHoraire, a_lieuEtDateCalcul.ChangementHeure, a_lieuEtDateCalcul.DeltaT);
// Calcul itératif pour l'heure de lever du Soleil
do
{
// Paramétrage de l'objet dateTemporaireCalcul avec l'heure de lever précédemment calculée
dateTemporaireCalcul.HeureLocale = heureLocaleLever;
// Calcul de dateTemporaireCalcul avec les nouveaux réglages
dateTemporaireCalcul.CalculerParametres();
// Calcul des paramètres du Soleil à l'instant différé
CalculerNonIteratif(dateTemporaireCalcul);
// Calcul de la précision atteinte
precision = this.heureLocaleLever - heureLocaleLever;
// Sauvegarde de la nouvelle heure de lever
heureSideraleVraieLocaleLever = this.heureSideraleVraieLocaleLever;
azimutLever = this.azimutLever;
heureSideraleVraieAGreenwichLever = this.heureSideraleVraieAGreenwichLever;
heureTULever = this.heureTULever;
heureLocaleLever = this.heureLocaleLever;
} while (precision > TimeSpan.FromSeconds(59.0)); // Précision de 1 minute
// Calcul itératif pour l'heure de coucher du Soleil
do
{
// Paramétrage de l'objet dateTemporaireCalcul avec l'heure de coucher précédemment calculée
dateTemporaireCalcul.HeureLocale = heureLocaleCoucher;
// Calcul de dateTemporaireCalcul avec les nouveaux réglages
dateTemporaireCalcul.CalculerParametres();
// Calcul des paramètres du Soleil à l'instant différé
CalculerNonIteratif(dateTemporaireCalcul);
// Calcul de la précision atteinte
precision = this.heureLocaleCoucher - heureLocaleCoucher;
// Sauvegarde de la nouvelle heure de coucher
heureSideraleVraieLocaleCoucher = this.heureSideraleVraieLocaleCoucher;
azimutCoucher = this.azimutCoucher;
heureSideraleVraieAGreenwichCoucher = this.heureSideraleVraieAGreenwichCoucher;
heureTUCoucher = this.heureTUCoucher;
heureLocaleCoucher = this.heureLocaleCoucher;
} while (precision > TimeSpan.FromSeconds(59.0)); // Précision de 1 minute
// Calcul des paramètres du Soleil pour la date et l'heure considérée
CalculerNonIteratif(a_lieuEtDateCalcul);
// Affectation des heures de lever et de coucher calculées
this.heureSideraleVraieLocaleLever = heureSideraleVraieLocaleLever;
this.azimutLever = azimutLever;
this.heureSideraleVraieLocaleCoucher = heureSideraleVraieLocaleCoucher;
this.azimutCoucher = azimutCoucher;
this.heureSideraleVraieAGreenwichLever = heureSideraleVraieAGreenwichLever;
this.heureSideraleVraieAGreenwichCoucher = heureSideraleVraieAGreenwichCoucher;
this.heureTULever = heureTULever;
this.heureTUCoucher = heureTUCoucher;
this.heureLocaleLever = heureLocaleLever;
this.heureLocaleCoucher = heureLocaleCoucher;
}
/// <summary>
/// Calcule les paramètres d'une planète pour le lieu d'observation et la date de calcul spécifié. La méthode effectue tous les calculs du synoptique
/// de façon itérative jusqu'à convergence des heures de lever et de coucher.
/// </summary>
/// <param name="a_lieuEtDateCalcul">Lieu d'observation et date pour le calcul.</param>
/// <param name="a_terreSoleil">Objet Soleil calculé pour le lieu d'observation et la date du caluul.</param>
/// <returns>Résultat du succès (true) ou de l'échec (false) du calcul de convergence des heures de lever et de coucher.</returns>
public bool CalculerIteratif(PositionTemps a_lieuEtDateCalcul, CorpsSystemeSolaire a_terreSoleil)
{
// Déclaration des variables de la méthode
double heureSideraleVraieLocaleLever; // Heure sidérale vraie locale de lever
double azimutLever; // Azimut de lever
double heureSideraleVraieLocaleCoucher; // Heure sidérale vraie locale de coucher
double azimutCoucher; // Azimut de coucher
double heureSideraleVraieAGreenwichLever; // Heure sidérale vraie à Greenwich de lever
double heureSideraleVraieAGreenwichCoucher; // Heure sidérale vraie à Greenwich de coucher
double heureTULever; // Heure TU de lever
double heureTUCoucher; // Heure TU de coucher
DateTime heureLocaleLever = new DateTime(); // Heure locale de lever
DateTime heureLocaleCoucher = new DateTime(); // Heure locale de coucher
TimeSpan precision = new TimeSpan(); // variable de contrôle de la convergence
PositionTemps dateTemporaireCalcul = null; // Objet PositionTemps pour le calcul en temps différé
Soleil terreSoleil = null; // Objet Soleil pour le calcul en temps différé des paramètres du Soleil
int compteur; // Variable de contrôle de la convergence du calcul
bool succes = true;
// Calcul initial des paramètres de la planète
CalculerNonIteratif(a_lieuEtDateCalcul, a_terreSoleil);
// Sauvegarde des heures de lever et de coucher
heureSideraleVraieLocaleLever = this.heureSideraleVraieLocaleLever;
azimutLever = this.azimutLever;
heureSideraleVraieLocaleCoucher = this.heureSideraleVraieLocaleCoucher;
azimutCoucher = this.azimutCoucher;
heureSideraleVraieAGreenwichLever = this.heureSideraleVraieAGreenwichLever;
heureSideraleVraieAGreenwichCoucher = this.heureSideraleVraieAGreenwichCoucher;
heureTULever = this.heureTULever;
heureTUCoucher = this.heureTUCoucher;
heureLocaleLever = this.heureLocaleLever;
heureLocaleCoucher = this.heureLocaleCoucher;
// Création et initialisation d'un nouvel objet PositionTemps pour calculer les heures de lever et de coucher en temps différé
dateTemporaireCalcul = new PositionTemps(a_lieuEtDateCalcul.LieuObservation, a_lieuEtDateCalcul.HeureLocale.Year, a_lieuEtDateCalcul.HeureLocale.Month, a_lieuEtDateCalcul.HeureLocale.Day, heureLocaleLever.Hour, heureLocaleLever.Minute, 0, a_lieuEtDateCalcul.ZoneHoraire, a_lieuEtDateCalcul.ChangementHeure, a_lieuEtDateCalcul.DeltaT);
// Calcul itératif pour l'heure de lever de la planète
compteur = 0;
do
{
// Paramétrage de l'objet dateTemporaireCalcul avec l'heure de lever précédemment calculée
dateTemporaireCalcul.HeureLocale = heureLocaleLever;
// Calcul de dateTemporaireCalcul avec les nouveaux réglages
dateTemporaireCalcul.CalculerParametres();
// Création et initialisation d'un nouvel objet Soleil pour calculer les heures de lever et de coucher en temps différé
terreSoleil = new Soleil();
terreSoleil.CalculerNonIteratif(dateTemporaireCalcul);
// Calcul des paramètres de la planète à l'instant différé
CalculerNonIteratif(dateTemporaireCalcul, terreSoleil);
// Au-delà de 6 itérations si le calcul n'a pas convergé, la méthode force la 2ème solution TU en ajoutant +23h56min04s si l'heure TU est compris entre 0h TU et 03h3min56s
if (compteur >= 6)
{
CalculerNonIteratif(dateTemporaireCalcul, terreSoleil, 1);
}
// Calcul de la précision atteinte
precision = this.heureLocaleLever - heureLocaleLever;
// Détection d'une absence de solution (cas d'un lever du corps céleste proche de minuit et oscillant autour de minuit)
if (precision > TimeSpan.FromHours(20))
{
this.azimutLever = TOUJOURS_INVISIBLE;
this.heureSideraleVraieLocaleLever = TOUJOURS_INVISIBLE;
this.heureSideraleVraieAGreenwichLever = TOUJOURS_INVISIBLE;
this.heureTULever = TOUJOURS_INVISIBLE;
this.heureLocaleLever = new DateTime();
precision = TimeSpan.FromSeconds(1);
}
// Sauvegarde de la nouvelle heure de lever
heureSideraleVraieLocaleLever = this.heureSideraleVraieLocaleLever;
azimutLever = this.azimutLever;
heureSideraleVraieAGreenwichLever = this.heureSideraleVraieAGreenwichLever;
heureTULever = this.heureTULever;
heureLocaleLever = this.heureLocaleLever;
// Incrémentation du compteur
compteur++;
// Au-delà de 10 itérations si le calcul n'a pas convergé, la méthode la boucle est stoppée
if (compteur == 10)
{
succes = false;
precision = TimeSpan.FromSeconds(1);
}
} while (precision > TimeSpan.FromSeconds(59.0)); // Précision de 1 minute
// Calcul itératif pour l'heure de coucher de la planète
compteur = 0;
do
{
// Paramétrage de l'objet dateTemporaireCalcul avec l'heure de coucher précédemment calculée
dateTemporaireCalcul.HeureLocale = heureLocaleCoucher;
// Calcul de dateTemporaireCalcul avec les nouveaux réglages
dateTemporaireCalcul.CalculerParametres();
// Création et initialisation d'un nouvel objet Soleil pour calculer les heures de lever et de coucher en temps différé
terreSoleil = new Soleil();
terreSoleil.CalculerNonIteratif(dateTemporaireCalcul);
// Calcul des paramètres de la planète à l'instant différé
CalculerNonIteratif(dateTemporaireCalcul, terreSoleil);
// Au-delà de 6 itérations si le calcul n'a pas convergé, la méthode force la 2ème solution TU en ajoutant +23h56min04s si l'heure TU est compris entre 0h TU et 03h3min56s
if (compteur >= 6)
{
CalculerNonIteratif(dateTemporaireCalcul, terreSoleil, 1);
}
// Calcul de la précision atteinte
precision = this.heureLocaleCoucher - heureLocaleCoucher;
// Détection d'une absence de solution (cas d'un coucher du corps céleste proche de minuit et oscillant autour de minuit)
if (precision > TimeSpan.FromHours(20))
{
this.azimutCoucher = TOUJOURS_INVISIBLE;
this.heureSideraleVraieLocaleCoucher = TOUJOURS_INVISIBLE;
this.heureSideraleVraieAGreenwichCoucher = TOUJOURS_INVISIBLE;
this.heureTUCoucher = TOUJOURS_INVISIBLE;
this.heureLocaleCoucher = new DateTime();
precision = TimeSpan.FromSeconds(1);
}
// Sauvegarde de la nouvelle heure de coucher
heureSideraleVraieLocaleCoucher = this.heureSideraleVraieLocaleCoucher;
azimutCoucher = this.azimutCoucher;
heureSideraleVraieAGreenwichCoucher = this.heureSideraleVraieAGreenwichCoucher;
heureTUCoucher = this.heureTUCoucher;
heureLocaleCoucher = this.heureLocaleCoucher;
// Incrémentation du compteur
compteur++;
// Au-delà de 10 itérations si le calcul n'a pas convergé, la méthode la boucle est stoppée
if (compteur == 10)
{
succes = false;
precision = TimeSpan.FromSeconds(1);
}
} while (precision > TimeSpan.FromSeconds(59.0)); // Précision de 1 minute
// Calcul des paramètres du Soleil pour la date et l'heure considérée
CalculerNonIteratif(a_lieuEtDateCalcul, a_terreSoleil);
// Affectation des heures de lever et de coucher calculées
this.heureSideraleVraieLocaleLever = heureSideraleVraieLocaleLever;
this.azimutLever = azimutLever;
this.heureSideraleVraieLocaleCoucher = heureSideraleVraieLocaleCoucher;
this.azimutCoucher = azimutCoucher;
this.heureSideraleVraieAGreenwichLever = heureSideraleVraieAGreenwichLever;
this.heureSideraleVraieAGreenwichCoucher = heureSideraleVraieAGreenwichCoucher;
this.heureTULever = heureTULever;
this.heureTUCoucher = heureTUCoucher;
this.heureLocaleLever = heureLocaleLever;
this.heureLocaleCoucher = heureLocaleCoucher;
return(succes);
}
