def coordonnees_moyennes_rigoureuses(HR, A):
"""
Calcul rigoureux des coordonnées moyennes de l'étoile:
en ascenscion droite
et en déclinaison de
pour l'année A.
Entrée :
HR = numéro de l'étoile
A = Année
Sortie :
dictionnaire :
'calculs' = calculs intermédiaires pour débogage
'RAf (°)' = ascension droite (°) de 0 à 360°
'DEf (°)' = déclinaison (°) de -90 à +90°
"""
calculs = []
resultat = {}
data = etoiles.etoile_data(HR)
pmRA = incert.it(data.pmRA, 0) / 1000
calculs.append({'pmRA (as/y)': pmRA})
pmDE = incert.it(data.pmDE, 0) / 1000
calculs.append({'pmDE (as/y)': pmDE})
alpha = int(data.RAh) + incert.i(int(data.RAm)) / 60
alpha += incert.i(data.RAs) / 3600
alpha *= 15
calculs.append({'RA0 (°)': alpha})
delta = int(data.DEsgn + data.DEd) + incert.i(int(data.DEm)) / 60
delta += incert.i(data.DEs) / 3600
calculs.append({'DEC0 (°)': delta})
deltaA = incert.it(A - 2000, 0)
calculs.append({'DeltaA (année)': deltaA})
alpha1 = (alpha + pmRA * deltaA / 3600) * incert.pi / 180
calculs.append({'alpha1 (°)': alpha1})
delta1 = (delta + pmDE * deltaA / 3600) * incert.pi / 180
calculs.append({'delta1 (°)': delta1})
t = deltaA / 100
calculs.append({'t (siècle)': t})
dzeta = (("2306.2181" * t + "0.30188" * t**2 + "0.017998" * t**3) /
3600) * incert.pi / 180
zed = (("2306.2181" * t + "1.09468" * t**2 + "0.018203" * t**3) /
3600) * incert.pi / 180
theta = (("2004.3109" * t + "0.42665" * t**2 + "0.041833" * t**3) /
3600) * incert.pi / 180
A = incert.cos(delta1) * incert.sin(alpha1 + dzeta)
B = incert.cos(theta)*incert.cos(delta1)*incert.cos(alpha1 + dzeta) \
- incert.sin(theta)*incert.sin(delta1)
C = incert.sin(theta)*incert.cos(delta1)*incert.cos(alpha1 + dzeta) \
+ incert.cos(theta)*incert.sin(delta1)
delta = incert.asin(C)
calculs.append({'delta (°)': delta})
alpha = incert.atan2(A, B) + zed
if (alpha.valeur < 0):
alpha += 2 * incert.pi
calculs.append({'alpha (°)': alpha})
resultat['calculs'] = calculs
resultat['RAf (°)'] = alpha * 180 / incert.pi
resultat['DEf (°)'] = delta * 180 / incert.pi
return resultat
def coordonnees_moyennes2(HR, A):
"""
Calcul les coordonnées moyennes de l'étoile:
en ascenscion droite
et en déclinaison de
pour l'année A première méthode matricielle.
Entrée :
HR = numéro de l'étoile
A = Année
Sortie :
dictionnaire :
'calculs' = calculs intermédiaires pour débogage
'RAf (°)' = ascension droite (°) de 0 à 360°
'DEf (°)' = déclinaison (°) de -90 à +90°
"""
calculs = []
resultat = {}
data = etoiles.etoile_data(HR)
pmRA = incert.it(data.pmRA, 0) / 1000
calculs.append({'pmRA (as/y)': pmRA})
pmDE = incert.it(data.pmDE, 0) / 1000
calculs.append({'pmDE (as/y)': pmDE})
alpha = int(data.RAh) + incert.i(int(data.RAm)) / 60
alpha += incert.i(data.RAs) / 3600
alpha *= 15
calculs.append({'RA0 (°)': alpha})
delta = int(data.DEsgn + data.DEd) + incert.i(int(data.DEm)) / 60
delta += incert.i(data.DEs) / 3600
calculs.append({'DEC0 (°)': delta})
deltaA = incert.it(A - 2000, 0)
calculs.append({'DeltaA (année)': deltaA})
S = deltaA / 100
calculs.append({'S (siècle)': S})
DS = deltaA / 1000
calculs.append({'DS (deca siècle)': DS})
RA1 = alpha + pmRA * deltaA / 3600
calculs.append({'RA1 (°)': RA1})
DE1 = delta + pmDE * deltaA / 3600
calculs.append({'DE1 (°)': DE1})
psi1 = RA1 * incert.pi / 180
phi1 = DE1 * incert.pi / 180
U1 = coord.xyzdepolaire(psi1, phi1, incert.un)
calculs.append({'U1 (m)': U1})
parametres = coord.parametres_precession(DS)
calculs += parametres['calculs']
U2 = coord.rotation3(-(parametres['zeta (")'] / 3600) * (incert.pi / 180),
U1)
U3 = coord.rotation2((parametres['theta (")'] / 3600) * (incert.pi / 180),
U2)
Uf = coord.rotation3(-(parametres['z (")'] / 3600) * (incert.pi / 180), U3)
(psif, phif, rf) = coord.polairedexyz(Uf)
if (psif.valeur < 0):
psif += incert.pi * 2
resultat['calculs'] = calculs
resultat['RAf (°)'] = psif * 180 / incert.pi
resultat['DEf (°)'] = phif * 180 / incert.pi
return resultat
def test_coordonnees_moyennes3(self):
afficher_calculs = False
RA = (incert.i(10) + incert.i(9) / 60 + incert.i("32.47") / 3600) * 15
DE = incert.i(11) + incert.i(51) / 60 + incert.i("31.9") / 3600
reponses = {'RAf (°)': RA, 'DEf (°)': DE}
resultat = coordonnees_moyennes3(3982, 2022.0)
if afficher_calculs:
print()
print("*************************************")
print("* test_coordonnees_moyennes3 *")
print("*************************************")
for ligne in resultat['calculs']:
print(ligne)
print('RAf (h) :', incert.tosexag(resultat['RAf (°)'] / 15))
print('DEf (°) :', incert.tosexag(resultat['DEf (°)']))
del resultat['calculs']
def test_parametres_precession(self):
afficher_calculs = False
reponses = [{
'm_alpha (s)': 3.071,
'n_alpha (s)': 1.337,
'n_delta (")': 20.06
}, {
'm_alpha (s)': 3.073,
'n_alpha (s)': 1.337,
'n_delta (")': 20.05
}, {
'm_alpha (s)': 3.075,
'n_alpha (s)': 1.336,
'n_delta (")': 20.04
}, {
'm_alpha (s)': 3.077,
'n_alpha (s)': 1.336,
'n_delta (")': 20.03
}, {
'm_alpha (s)': 3.079,
'n_alpha (s)': 1.335,
'n_delta (")': 20.03
}]
resultat = []
if afficher_calculs:
print()
print("**************************************")
print("* test_parametres_precession *")
print("**************************************")
for i in range(-2, 3):
parametres_i = parametres_precession(incert.i(i))
resultat.append(parametres_i)
if afficher_calculs:
print('----------- siècle :', 2000 + 100 * i)
print('m_alpha (s) :', parametres_i['m_alpha (s)'])
print('n_alpha (s) :', parametres_i['n_alpha (s)'])
print('n_delta (") :', parametres_i['n_delta (")'])
self.assertEqual(reponses, resultat)
def coordonnees_moyennes(HR, A):
"""
Calcul approximatif des coordonnées moyennes de l'étoile:
en ascenscion droite
et en déclinaison de
pour l'année A.
Entrée :
HR = numéro de l'étoile
A = Année
Sortie :
dictionnaire :
'calculs' = calculs intermédiaires pour débogage
'RAf (°)' = ascension droite (°) de 0 à 360°
'DEf (°)' = déclinaison (°) de -90 à +90°
"""
calculs = []
resultat = {}
data = etoiles.etoile_data(HR)
calculs.append({'pmRA (mas/y)': data.pmRA})
pmRA = incert.i(data.pmRA) / (15 * 1000)
calculs.append({'pmRA (s/y)': pmRA})
calculs.append({'pmDE (mas/y)': data.pmDE})
pmDE = incert.i(data.pmDE) / 1000
calculs.append({'pmDE ("s/y)': pmDE})
alpha = int(data.RAh) + incert.i(int(data.RAm)) / 60
alpha += incert.i(data.RAs) / 3600
alpha *= 15
calculs.append({'RA0 (°)': alpha})
delta = int(data.DEsgn + data.DEd) + incert.i(int(data.DEm)) / 60
delta += incert.i(data.DEs) / 3600
calculs.append({'DEC0 (°)': delta})
deltaA = incert.it(A - 2000, 0)
calculs.append({'DeltaA (année)': deltaA})
S = deltaA / 100
calculs.append({'S (siècle) ': S})
parametres = parametres_precession(S)
m_alpha = parametres['m_alpha (s)']
n_alpha = parametres['n_alpha (s)']
n_delta = parametres['n_delta (")']
calculs.append({'m_alpha (s)': m_alpha})
calculs.append({'n_alpha (s)': n_alpha})
calculs.append({'n_delta (")': n_delta})
precRA = n_alpha * incert.sin(incert.pi * alpha / 180)
precRA *= incert.tan(incert.pi * delta / 180)
precRA += m_alpha
calculs.append({'precRA (s)': precRA})
precDE = n_delta * incert.cos(incert.pi * alpha / 180)
calculs.append({'precDE (")': precDE})
varRA = precRA + pmRA
calculs.append({'varRA (s)': varRA})
varDE = precDE + pmDE
calculs.append({'varDE (")': varDE})
calculs.append({'delta A (an)': deltaA})
varRAtot = varRA * deltaA
calculs.append({'varRAtot (s)': varRAtot})
varDEtot = varDE * deltaA
calculs.append({'varDEtot (")': varDEtot})
RAf = alpha + varRAtot * 15 / 3600
calculs.append({'RAf (°)': RAf})
DEf = delta + varDEtot / 3600
calculs.append({'DEf (°)': DEf})
resultat['calculs'] = calculs
resultat['RAf (°)'] = RAf
resultat['DEf (°)'] = DEf
return resultat
def test_rotations(self):
afficher_calculs = False
reponses = {}
reponse = vecteur(incert.i(3), incert.i(-2), incert.i(1))
U0 = vecteur(incert.i(1), incert.i(2), incert.i(3))
U1 = rotation1(incert.pi/2, U0)
reponse1 = vecteur(incert.i(1), incert.i(3), incert.i(-2))
self.assertTrue(egalite_vecteurs(U1, reponse1))
U2 = rotation2(incert.pi/2, U0)
reponse2 = vecteur(incert.i(-3), incert.i(2), incert.i(1))
self.assertTrue(egalite_vecteurs(U2, reponse2))
U3 = rotation3(incert.pi/2, U0)
reponse3 = vecteur(incert.i(2), incert.i(-1), incert.i(3))
self.assertTrue(egalite_vecteurs(U3, reponse3))