#--------------------------------------------------------#
#
#            Exemple de regression linéaire
#
#  - Loi de Snell-Descartes sin r =  n  sin i
#  - On dispose d'un ensemble de valeurs mesurées pour r et i
#
#  - On effectue la régression linéaire avec contrôle
#    visuel par les résidus ou par l'écart normalisé
#
#  - On établit n son 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
#--------------------------------------------------------#

# donnees angle d'incidence
i = np.array([-40,-30,-20,-10,0,10,20,30,40])*np.pi/180
# incertitudes
ui_lecture = 0.5 # echelle graduée
ui_plage = np.array([0.5]*9) # largeur du faisceau incident
ui = np.sqrt(ui_lecture**2 + ui_plage**2)*np.pi/180

# donnees angle de réfraction
r = np.array([-74,-48,-31,-15,0,16,30,49,77])*np.pi/180
# incertitudes
ur_lecture = 0.5 # echelle graduée
ur_plage = np.array([3,2,1,1,1,1,1,2,3]) # largeur du faisceau incident
ur = np.sqrt(ur_lecture**2 + ur_plage**2)*np.pi/180



#-----------------------------------------------------------#
#  Construction de X et de Y 
#-----------------------------------------------------------#

NMC  = 50000 # nombre simulations

X  = np.array([0.]*len(i))
uX  = np.array([0.]*len(i))
Y  = np.array([0.]*len(r))
uY  = np.array([0.]*len(r))

for k in range(len(X)):
  i_MC = np.array(rd.normal(i[k],ui[k],NMC))
  X[k] = np.average(np.sin(i_MC))
  uX[k] = np.std(np.sin(i_MC),ddof  = 1)

  r_MC = rd.normal(r[k],ur[k],NMC)
  Y[k] = np.average(np.sin(r_MC))
  uY[k] = np.std(np.sin(r_MC),ddof  = 1)  


#--------------------------------------------------------#
#    Ajustement affine 
#--------------------------------------------------------#
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[0])
print("Ordonnée à l'origine = ", p[1])





#-----------------------------------------------------------#
#     Tracé des points expérimentaux et de la droite modèle
#-----------------------------------------------------------#
plt.figure("Direct")
plt.errorbar(X,Y, xerr = uX, yerr = uY, 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"$sin i$ ")
plt.ylabel(r"$sin r$")
plt.grid(), plt.legend(loc = 'best')





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

# calcul des résidus
residus = Y - Yreg

# résidus avec barres d'incertitude-type
plt.errorbar(X, residus, yerr = uY, 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([-1, 1], [0, 0], 'c--')

# Axes et légendes
plt.xlabel(r"$\sin i $ (en nm)"), plt.xlim(-1, 1)
plt.ylabel(r"résidus"), plt.ylim(-3e-2, 3e-2), 
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/uY

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

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

# Axes et légendes
plt.xlabel(r"$i$ (en rad)"), plt.xlim(-1, 1)
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 n
n_MC = []


# On simule NMC expériences à partir des valeurs obtenues et de
# leurs incertitudes

for _ in range(NMC):
  # Nouvelle liste d'angles d'incidence
  iN = i + rd.normal(0, ui, size = len(i))

  # Nouvelle liste d'angles de réfraction
  rN = r + rd.normal(0, ur, size = len(r))

  Xn  = np.sin(rN)
  Yn = np.sin(iN)
  # on reprend l'ajustement affine avec cette série de valeurs de n
  p = np.polyfit(Yn, Xn, 1)
  
  # on stocke les valeurs des paramètres d'ajustement dans les listes Amc et Bmc
  n_MC.append(p[0])




# Analyse statistique  (type A) de l'ensemble des valeurs de A et de B obtenues
print('---------------------------')
n_moy = np.mean(n_MC)
u_n = np.std(n_MC, ddof = 1)
print("Estimation Monte-Carlo de l'indice  :")
print("* Valeur mesurée : n = {}".format(n_moy))
print("* Incertitude-type : u(n) = {}\n".format(u_n))


# Calcul type A direct
i = np.array([-40,-30,-20,-10,10,20,30,40])*np.pi/180
r = np.array([-74,-48,-31,-15,16,30,49,77])*np.pi/180

nA = np.sin(r)/np.sin(i)

n = np.average(nA)
un = np.std(nA,ddof = 1)
print(n,un)
