#--------------------------------------------------------#
#
#            Exemple de regression linéaire
#
#  -  Loi de Cauchy n  = A + B/lambda^2
#  - On dispose d'un ensemble de valeurs mesurées pour n
#  - Et d'un ensemble de valeurs tabulées pour lambda
#
#  - On effectue la régression linéaire avec contrôle
#    visuel par les résidus ou par l'écart normalisé
#
#  - On établit A et B et leur incertitude type par
#    simulation Monte-Carlo

#--------------------------------------------------------#




## Importation des bibliothèques utiles
import numpy as np                   # pour le traitement vectoriel des données
import matplotlib.pyplot as plt      # pour les tracés
import numpy.random as rd            # pour les tirages aléatoires

#--------------------------------------------------------#
#     Données expérimentales
#--------------------------------------------------------#

# Les longueurs d'onde (en nm)
lamb = np.array([404.7, 435.8, 480.0, 546.1, 578.1, 615])

# Les indices 
n = np.array([1.7761, 1.7632, 1.7496, 1.7348, 1.7294, 1.7240])

# Les incertitudes-type des indices
u_n = np.array([1.4, 1.4, 1.4, 1.3, 1.3, 1.3])*1e-3




#--------------------------------------------------------#
#    Ajustement affine 
#--------------------------------------------------------#
Y , X = n , 1/lamb**2               
p = np.polyfit(X, Y, 1)

# p est un tableau contenant les coefficients de l'ajustement 
# p[0] : pente ; p[1] : ordonnée à l'origine


# calcul des ordonnées des points du modèle
Yreg = p[0]*X + p[1]

# Affichage du résultat: 
print("Pente = ", p[1])
print("Ordonnée à l'origine = ", p[0])





#-----------------------------------------------------------#
#     Tracé des points expérimentaux et de la droite modèle
#-----------------------------------------------------------#
plt.figure("Direct")
plt.errorbar(X, Y, yerr = u_n, fmt = 'bo',label = "Points expérimentaux")    # points expérimentaux
plt.plot(X, Yreg, '-',label = "Modèle affine",color="magenta")                            # points issus de l'ajustement

# Axes et légendes
plt.xlabel(r"$1/\lambda^2$ (en nm$^{-2}$)")
plt.ylabel(r"$n$")
plt.grid(), plt.legend(loc = 'best')



#-----------------------------------------------------------#
#  Contrôle par le calcul des résidus 
#-----------------------------------------------------------#
plt.figure("Residus")

# calcul des résidus
residus = n - Yreg

# résidus avec barres d'incertitude-type
plt.errorbar(lamb, residus, yerr = u_n, fmt = 'bo')
# remarque: l'incertitude type ici est la même que celle portant sur Y
# car il n'y a pas d'incertitude sur les valeurs de lambda. Dans le cas contraire
# il faut la calculer par propagation

# pour mieux visualiser la droite correspondant à un résidu nul
plt.plot([350, 650], [0, 0], 'c--')

# Axes et légendes
plt.xlabel(r"$\lambda$ (en nm)"), plt.xlim(350, 650)
plt.ylabel(r"résidus"), plt.ylim(-3e-3, 3e-3), 
plt.ticklabel_format(axis = 'y', style = 'sci', scilimits = (0,0))
plt.grid()




#-----------------------------------------------------------#
#  Contrôle par les écarts normalisés
#-----------------------------------------------------------#
plt.figure("Ecarts normalisés")
# calcul des écarts normalisés
En = residus/u_n

# Tracé
plt.plot(lamb, En, 'bo')             

# pour mieux visualiser le domaine des écarts acceptables
plt.fill_between([350, 650], y1 = -2, y2 = 2, color = 'cyan', alpha = .1)

# Axes et légendes
plt.xlabel(r"$\lambda$ (en nm)"), plt.xlim(350, 650)
plt.ylabel(r"écarts normalisés"), plt.ylim(-3,3)
plt.grid()


#-----------------------------------------------------------#
#  Affichage des trois graphiques
#-----------------------------------------------------------#
plt.show()





#-----------------------------------------------------------#
#  Evaluation de l'incertitude sur A et B
#  par simulation Monte-Carlo
#-----------------------------------------------------------#

# nombre d'expériences simulées
NMC = 50000

# initialisation des listes dans lesquelles on va stocker
# les valeurs de A et B correspondant à chaque expérience simulée
Amc, Bmc = [], []

# pour chaque expérience, on simule la mesure des indices pour les 6 longueurs d'onde
# en utilisant une valeur aléatoire pour les indices

for i in range(NMC):
  # Nouvelle liste d'indice
  nMC = n + rd.normal(0, u_n, size = 6)
  
  # on reprend l'ajustement affine avec cette série de valeurs de n
  p = np.polyfit(1/lamb**2, nMC, 1)
  
  # on stocke les valeurs des paramètres d'ajustement dans les listes Amc et Bmc
  Amc.append(p[1])
  Bmc.append(p[0])



# Analyse statistique  (type A) de l'ensemble des valeurs de A et de B obtenues
print('---------------------------')
Amoy = np.mean(Amc)
u_A = np.std(Amc, ddof = 1)
print("Estimation Monte-Carlo du paramètre A de la loi de Cauchy :")
print("* Valeur mesurée : A = {}".format(Amoy))
print("* Incertitude-type : u(A) = {}\n".format(u_A))

Bmoy = np.mean(Bmc)
u_B = np.std(Bmc, ddof = 1)
print("Estimation  Monte-Carlo du paramètre B de la loi de Cauchy :")
print("* Valeur mesurée : B = {}".format(Bmoy))
print("* Incertitude-type : u(B) = {}".format(u_B))


