{ "cells": [ { "cell_type": "markdown", "id": "a117c8df", "metadata": {}, "source": [ "# Modèle de Snell-Descartes\n", "\n", "On commence par importer les library utiles pour réaliser les simulations numériques." ] }, { "cell_type": "code", "execution_count": 1, "id": "16b7761b", "metadata": {}, "outputs": [], "source": [ "#on commence classiquement par importer la library numpy (sous l'alias np) pour le calcul numérique\n", "#son sous module numpy.random pour effectuer les tirages aléatoires selon des lois bien controlées\n", "#et la library matplotlib.pyplot (sous l'alias pl) pour la réalisation de graphique.\n", "import numpy as np\n", "import numpy.random as rd\n", "import matplotlib.pyplot as pl" ] }, { "cell_type": "markdown", "id": "2abaf0e6", "metadata": {}, "source": [ "## Evaluation de l'incertitude sur sin(i0) et sin(i1)" ] }, { "cell_type": "markdown", "id": "13579378", "metadata": {}, "source": [ "Pour évaluer l'incertitude sur le sinus d'un angle, connaissant l'incertitude sur l'angle lui même, on va à nouveau exploiter une simulation de Monte Carlo. Cette démarche sera obligatoire dès que le lien entre la grandeur directement issue de l'expérience et la grandeur à évaluer est complexe. Un petit nombre de situation donnera lieu à un traitement direct sans passer forcément par l'outil de simulation (cas d'une formule de type somme ou produit)." ] }, { "cell_type": "code", "execution_count": 2, "id": "b55df4e8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "la valeur moyenne du sin(i0) est égale à 0.643\n", "la valeur moyenne du sin(i1) est égale à 0.966\n", "l'incertitude associée à sin(i0) est égale à 0.008\n", "l'incertitude associée à sin(i1) est égale à 0.005\n", "l'évaluation de l'indice obtenu est 1.503\n", "l'évaluation de l'incertitude sur l'indice est 0.02\n" ] } ], "source": [ "#on créée une liste de 10000 tirages aléatoires uniformément répartis sur l'intervalle étudié.\n", "#ce qu'on appelle généralement simulation Monte-Carlo.\n", "N=10000\n", "\n", "#valeur expérimentale de i0 l'angle d'incidence et i1 l'angle de réfraction\n", "angle_incidence=40\n", "angle_refraction=75\n", "\n", "\n", "#Demi largeur de l'intervalle de mesure\n", "l_angle_inc=1\n", "l_angle_refrac=2\n", "\n", "# simultation montéCarlo pour le sin(i0) et le sin(i1)\n", "angle_incidence_MC=angle_incidence+rd.uniform(-l_angle_inc,l_angle_inc,N)\n", "sin_incidence_MC=np.sin(np.pi/180*angle_incidence_MC)\n", "\n", "angle_refraction_MC=angle_refraction+rd.uniform(-l_angle_refrac,l_angle_refrac,N)\n", "sin_refraction_MC=np.sin(np.pi/180*angle_refraction_MC)\n", "\n", "#on calcul les valeurs moyennes sur le tirage aléatoire réalisé\n", "moyenne_incidence=round(np.average(sin_incidence_MC),3)\n", "print(\"la valeur moyenne du sin(i0) est égale à \",moyenne_incidence)\n", "\n", "moyenne_refraction=round(np.average(sin_refraction_MC),3)\n", "print(\"la valeur moyenne du sin(i1) est égale à \",moyenne_refraction)\n", "\n", "#on calcul les écarts type sur le tirage aléatoire réalisé\n", "u_incidence=round(np.std(sin_incidence_MC,ddof=1),3)\n", "print(\"l'incertitude associée à sin(i0) est égale à \",u_incidence)\n", "u_refraction=round(np.std(sin_refraction_MC,ddof=1),3)\n", "print(\"l'incertitude associée à sin(i1) est égale à \",u_refraction)\n", "\n", "#on obtient enfin une évaluation de n et l'incertitude associé\n", "indice_MC=sin_refraction_MC/sin_incidence_MC\n", "moyenne_indice=round(np.average(indice_MC),3)\n", "print(\"l'évaluation de l'indice obtenu est\", moyenne_indice)\n", "u_indice=round(np.std(indice_MC),3)\n", "print(\"l'évaluation de l'incertitude sur l'indice est\", u_indice)" ] }, { "cell_type": "markdown", "id": "a62f098b", "metadata": {}, "source": [ "## exemple de tableau de résultats obtenus\n", "\n", "On reprend alors les résultats obtenus par la simulation sous python pour établir le tableau complet des moyennes et incertitudes sur toutes les grandeurs évaluées dans cette expérience :\n", "\n", "|i0|i1|sin(i0)|u(sin(i0))|sin(i1)|u(sin(i1))|n|u(n)|\n", "|:-----:|:-----:|:-----:|:-----:|:-----:|:-----:|:-----:|:-----:|\n", "|5|7|0,087|0,005|0,122|0,005|1,403|0,10|\n", "|10|15|0,174|0,005|0,259|0,005|1,492|0,051|\n", "|15|22|0,259|0,005|0,375|0,009|1,448|0,045|\n", "|20|31|0,342|0,01|0,515|0,009|1,507|0,049|\n", "|25|40|0,423|0,009|0,643|0,008|1,522|0,038|\n", "|30|48|0,5|0,009|0,743|0,007|1,487|0,029|\n", "|35|59|0,573|0,008|0,857|0,005|1,495|0,023|\n", "|40|75|0,643|0,008|0,966|0,005|1,503|0,020|\n" ] }, { "cell_type": "markdown", "id": "71227bdc", "metadata": {}, "source": [ "## Tracé de la courbe expérimentale sin(i1)=f(sin(i0))" ] }, { "cell_type": "code", "execution_count": 3, "id": "608bd025", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#On construit les tableaux des valeurs des angles mesurés.\n", "angle_inc=np.array([5,10,15,20,25,30,35,40])\n", "angle_ref=np.array([7,15,22,31,40,48,59,75])\n", "\n", "# On construit les tableaux des valeurs d'angle associés.\n", "sin_inc=np.sin(np.pi/180*angle_inc)\n", "sin_ref=np.sin(np.pi/180*angle_ref)\n", "\n", "#on construit les tableaux des incertitudes sur chaque valeur de sinus\n", "u_inc=np.array([0.005,0.005,0.005,0.01,0.009,0.009,0.008,0.008])\n", "u_ref=np.array([0.005,0.005,0.009,0.009,0.008,0.007,0.005,0.005])\n", "\n", "# création d'une figure\n", "pl.figure(figsize = (7,7))\n", "# représentation des points expérimentaux avec barres d'incertitude à \\pm u\n", "pl.errorbar(sin_inc, sin_ref, xerr = u_inc, yerr = u_ref, fmt = ',', color = 'r')\n", "\n", "#déco axe des abscisses\n", "pl.xlim(0,0.7), pl.xlabel(\"sin(i0)\")\n", "#déco axe des ordonnées\n", "pl.ylim(0,1.), pl.ylabel(\"sin(i1)\")\n", "\n", "#axe des abscisses et axe des ordonnées sur la même échelle\n", "#pl.axis(\"equal\")\n", "#Affichage d'une grille\n", "pl.grid()\n", "\n", "#affichage de la figure\n", "pl.show()\n", "\n" ] }, { "cell_type": "markdown", "id": "082bad31", "metadata": {}, "source": [ "On peut observer alors que :\n", "- L'allure de la courbe semble bien corroborrée un modèle linéaire (ou affine). On illustrera par la suite la vérification avec des critère plus précis de cette affirmation.\n", "- La pente de cette droite donne alors la valeur expérimentale de l'indice optique mais elle ne donne pas accès à l'incertitude sur cette mesure." ] }, { "cell_type": "markdown", "id": "9b3b1f81", "metadata": {}, "source": [ "## Vérification du modèle linéaire par évaluation des résidus.\n", "\n", "Pour vérifier le modèle linéaire, on va :\n", "- effectuer une régression linéaire avec python pour déterminer la meilleure droite modèle.\n", "- Evaluer et représenter les résidus avec les barres d'erreur.\n", "- Discuter de l'allure de la courbe obtenue." ] }, { "cell_type": "code", "execution_count": 4, "id": "de40403e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "l'indice optique est estimé par la pente qui vaut : 1.514230191731425\n", "mais il manque l'évaluation de l'incertitude sur cette pente !!!\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#on détermine les paramètres de la modélisation affine se rapprochant le plus possible du nuage de points expérimental.\n", "# la liste p produite par la fonction polyfit de la librairy numpy est la liste des coefficients polynomiaux\n", "p = np.polyfit(sin_inc, sin_ref, 1)\n", "\n", "#affichage de la valeur de la pente donnant la valeur estimée de n\n", "print(\"l'indice optique est estimé par la pente qui vaut : \",p[0])\n", "print(\"mais il manque l'évaluation de l'incertitude sur cette pente !!!\")\n", "\n", "\n", "# On trace sur une figure le nuage de points expérimentaux et la drotie d'ajustement\n", "pl.figure(figsize = (5,5))\n", "\n", "# on effectue une représentation des points expérimentaux\n", "pl.errorbar(sin_inc, sin_ref, xerr = u_inc, yerr = u_ref, fmt = ',', color = 'k', label = 'Points expérimentaux')\n", "\n", "# représentation de la droite d'ajustement \n", "pl.plot(sin_inc, np.polyval(p,sin_inc), 'k--', label = 'Modèle affine')\n", "\n", "pl.show()\n" ] }, { "cell_type": "markdown", "id": "2d81a14d", "metadata": {}, "source": [ "La droite modèle et le nuage de points expérimentaux semble bien correspondre, mais les barres d'erreur étant très petites, cette représentation graphique ne permet pas de conclure avec une sécurité totale. On va donc étudier la représentation graphique des résidus, et des écarts normalisés." ] }, { "cell_type": "code", "execution_count": 5, "id": "441d29a9", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "#on calcul les résidus c'est à dire l'écart entre les points expérimentaux et le modèle affine\n", "residus = (sin_ref - np.polyval(p,sin_inc))\n", "\n", "## Vérification graphique de la pertinence (ou non !) de la modélisation par représentation des écarts normalisés\n", "# c'est à dire le rapport des résidus et de l'incertitude type sur le point de mesure associé\n", "pl.figure(figsize = (5,5))\n", "\n", "\n", "# représentation des points expérimentaux\n", "pl.errorbar(sin_inc, residus/u_ref, xerr = u_inc, yerr = u_ref, fmt = ',', color = 'r', label = 'Points expérimentaux')\n", "\n", "\n", "pl.xlim(0,0.75), pl.xlabel(\"sin(i0)\") \n", "pl.ylim(-2,2), pl.ylabel(\"résidus\")\n", "pl.grid(), pl.legend(loc = 0)\n", "\n", "pl.show()" ] }, { "cell_type": "markdown", "id": "2219bc3e", "metadata": {}, "source": [ "- L'affichage de l'écart normalisé, raport des résidus avec l'incertitude sur la valeur de sin(i1) donne des valeurs qui sont toutes dans l'intervalle [-2,2]. \n", "- Les points sont distribués autour de la valeur nulle de manière qui semble aléatoire, on n'identifie par d'évolution continue de la position des points dans le graphique représentant les résidus.\n", "**On peut alors conclure que le modèle affine est bien vérifié." ] }, { "cell_type": "markdown", "id": "82331f00", "metadata": {}, "source": [ "## Simulation Monte Carlo pour la loi de Snell-Descartes.\n", "\n", "La simulation Monte Carlo peut aussi s'appliquer à la construction de la droite de régression étudiée précédemment. En effectuant N tirages aléatoires sur cette droite de régression, on aura accès à N valeurs de la pente. On pourra alors appliquer un traitement statistique pour obtenir une évaluation de l'indice optique n qui sera complète, avec une valeur éstimée obtenue par évaluation de la moyenne de ces pentes, et une incertitude type obtenue par évaluation de l'écart-type standard.\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "2c33ea54", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "La moyenne des pentes sur les tirages aléatoires est 1.535914637892687\n", "l'incertitude entre les tirages aléatoires est 0.0696181097095728\n" ] } ], "source": [ "#on identifie le nombre de mesures effectuées\n", "n_mesure=len(angle_inc)\n", "\n", "#on initialise un tableau de tirages aléatoires sur l'angle incident\n", "angle_inc_MC=np.zeros([N,n_mesure])\n", "\n", "for i in range(n_mesure):\n", "#on construit alors le tableau des tirages aléatoire pour l'angle d'incidence\n", " angle_inc_MC[:,i]=angle_inc[i]+rd.normal(-l_angle_inc,l_angle_inc,N)\n", "#on construit le tableau des tirages aléatoire pour le sinus de l'angle d'incidence\n", " sin_inc_MC=np.sin(np.pi/180*angle_inc_MC)\n", "\n", "#on reprend la démarche pour l'angle de réfraction \n", "#on initialise un tableau de tirages aléatoires sur l'angle incident\n", "angle_ref_MC=np.zeros([N,n_mesure])\n", "\n", "for i in range(n_mesure):\n", "#on construit alors le tableau des tirages aléatoire pour l'angle de réfraction\n", " angle_ref_MC[:,i]=angle_ref[i]+rd.normal(-l_angle_refrac,l_angle_refrac,N)\n", "#on construit le tableau des tirages aléatoire pour le sinus de l'angle de réfraction\n", " sin_ref_MC=np.sin(np.pi/180*angle_ref_MC)\n", "\n", "\n", "#On initialise une liste des évaluations de l'indice en la prenant vide.\n", "list_indice=[]\n", "\n", "for i in range(N):\n", "#on effectue la régression linéaire sur les N simulations de nuages de points avec polyfit\n", " p = np.polyfit(sin_inc_MC[i,:], sin_ref_MC[i,:], 1)\n", "#On extrait la pente de la droite pour chaque simulation et on l'enregistre dans la liste.\n", " list_indice=list_indice+[p[0]]\n", "\n", "# On évalue la moyenne des pente pour obtenir une estimation de la valeur de l'indice. \n", "moyenne_list_indice=np.average(list_indice)\n", "#on évalue l'acert type pour avoir accès à l'incertitude type\n", "u_list_indice=np.std(list_indice)\n", "\n", "print(\"La moyenne des pentes sur les tirages aléatoires est\",moyenne_list_indice)\n", "print(\"l'incertitude entre les tirages aléatoires est\", u_list_indice)" ] }, { "cell_type": "markdown", "id": "af693aa4", "metadata": {}, "source": [ "**La conclusion à laquelle on aboutit est alors la suivante par exploitation de cette simulation Monte Carlo**\n", "- L'indice optique du plexiglas est n=1,54 avec une incertitude type u(n)=0,07 (avec un seul chiffre pour l'incertitude)\n", "- L'indice optique du plexiglas est n=1,536 avec une incertitude type u(n)=0,070 (avec deux chiffres pour l'incertitude)\n" ] }, { "cell_type": "markdown", "id": "27a70e7a-0b45-4e99-a307-85181434ee80", "metadata": {}, "source": [ "On évalue alors la compatibilité de ce résultat expérimental avec la valeur tabulée pour le plexiglas, $n_{plexiglass}$=1,50, en évaluant l'écart normalisé, encore appelé Z-score, entre la valeur expérimentale (n=1,51 ; u(n)=0,03) et la valeur théorique, en exploitant la définition :\n", "
$Z_{score}=\\left|\\frac{n-n_{plexiglass}}{u\\left(n\\right)}\\right|$
" ] }, { "cell_type": "code", "execution_count": 19, "id": "24be6b54", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "le Z score est de 0.385822125170563 , il est inférieur ou égale à 2\n", "la mesure effectuée est cohérente avec la valeur théorique tabulée\n" ] } ], "source": [ "n_plexiglas=1.5\n", "Z=np.abs((moyenne_list_indice-n_plexiglas)/u_list_indice)\n", "if Z<=2:\n", " print(\"le Z score est de\",Z,\", il est inférieur ou égale à 2\")\n", " print(\"la mesure effectuée est cohérente avec la valeur théorique tabulée\")\n", "else :\n", " print(\"le Z score est de\",Z,\", il est supérieur à 2\")\n", " print(\"la mesure effectuée n'est pas cohérente avec la valeur théorique tabulée\")\n" ] }, { "cell_type": "markdown", "id": "37c72a9e-5f82-48cd-bbac-8254856a65c3", "metadata": {}, "source": [ "On évalue aussi vérifier la compatibilité de son résultat et de celui de son voisin en évaluant le Z-score en exploitant la définition :\n", "center $Z_{1/2}=\\frac{|n_{1}-n_{2}|}{\\sqrt{u_{1}^2(n)+u_{2}^2(n)}}$\n" ] }, { "cell_type": "code", "execution_count": 12, "id": "77c35b81-c7c8-479f-90dd-a3e738ed5208", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "le Z score est de 1.386750490563074 , il est inférieur ou égale à 2\n", "la mesure effectuée est cohérente avec la valeur théorique tabulée\n" ] } ], "source": [ "monindice,monincert=1.51,0.03\n", "sonindice,sonincert=1.46,0.02\n", "Z2=np.abs(monindice-sonindice)/np.sqrt(monincert**2+sonincert**2)\n", "if Z2<=2:\n", " print(\"le Z score est de\",Z2,\", il est inférieur ou égale à 2\")\n", " print(\"la mesure effectuée est cohérente avec la valeur théorique tabulée\")\n", "else :\n", " print(\"le Z score est de\",Z2,\", il est supérieur à 2\")\n", " print(\"la mesure effectuée n'est pas cohérente avec la valeur théorique tabulée\")" ] }, { "cell_type": "code", "execution_count": null, "id": "bf310b59-55a9-478e-868c-11ea6bf4d176", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.18" } }, "nbformat": 4, "nbformat_minor": 5 }