Tracer une figure de diffraction avec matplotlib

Active 28 mai 2013    /    Viewed 2690    /    Comments 0    /    Edit


Introduction

[attachment:49] (télécharger le fichier résultat)

[attachment:48] (télécharger le code python)

Figure 1: Tracer une figure de diffraction avec matplotlib

Dans cet article nous allons voir comment tracer une figure de diffraction avec matplotlib (figure 1). Pour cela, nous allons étudier le code source permettant de reproduire l'image et commenter une par une les différentes lignes du code. Nous supposons ici que python et les bibliothèques numpy et matplotlib sont installés sur votre système.

Commençons tout d'abord par définir le point de départ de notre problème:
on dispose d'un fichier ASCII nommé output_diffraction
comprenant trois colonnes X, Y et Z (voir ci-dessous une partie du Fichier ASCII: output_diffraction). Les deux premières colonnes correspondent aux corrdonnées cartésiennes d'un point (en micromètre) situé dans un plan parallèle au plan de diffraction et la troisième colonne correspond à l'intensité lumineuse diffractée en ce point. Pour obtenir ce fichier, on a implementé un simple programme écrit en fortran 90 permettant de calculer la diffraction de Fraunhofer par une longueur d'onde et une ouverture rectangulaire de taille quelconque (vous trouverez sur les pages suivantes le code source du programme (todo) et l'ensemble du fichier output-diffraction).

Vous pouvez alors modifier les valeurs d'entrée du programme afin d'obtenir la diffraction de Fraunhofer en fonction de la longueur d'onde, de la taille de l'ouverture rectangulaire et de la distance entre l'écran et l'ouverture que vous voulez. Les valeurs par défaut dans le programme sont celles permettant d'obtenir le même fichier sortie output_diffraction présenté ci-dessous. Le problème maintenant est: comment à partir du fichier ascii output_diffraction, que nous venons de décrire, obtenir la figure 1 avec matplotlib ?.

 -300000.0  -300000.0  0.0000000003237889
 -300000.0  -299000.0  0.0000000000275715
 -300000.0  -298000.0  0.0000000000838257
 -300000.0  -297000.0  0.0000000006350461
 -300000.0  -296000.0  0.0000000018360795
 -300000.0  -295000.0  0.0000000038517949
 -300000.0  -294000.0  0.0000000068544099
 -300000.0  -293000.0  0.0000000110205025
 -300000.0  -292000.0  0.0000000165277609
 -300000.0  -291000.0  0.0000000235514960
     .          .              . 
     .          .              . 
     .          .              .

Description du code

Il existe plusieurs façon d'utiliser matplotlib. Vous pouvez
par exemple choisir de lancer directement l'interpreteur de commande python.
Dans ce cas vous devez taper une par une les différentes commandes dont
vous avez besoin pour tracer votre figure. Une autre possibilité, que nous adopterons la plupart du temps dans nos exemples, est d'écrire un script python comprenant l'ensemble des commandes dans un fichier ascii que l'on sauvegardera sous un nom du style: "nomdufichier.py" (le suffixe .py n'est pas obligatoire: il est surtout utile pour distinguer rapidement dans votre arborescence les fichiers contenant des commandes python). Pour notre problème, nous avons écrit le fichier diffraction.py (voir ci-dessous l'encadré Code Python (figure 1): diffraction.py). qui permet à partir du fichier résultat output_diffraction de tracer la figure de diffraction présentée au debut. Pour utiliser ce fichier, il suffit alors de taper dans votre interpréteur de commande: python diffraction.py , ce qui aura pour conséquence de créer dans votre répertoire courant une figure au format eps intitulée ici "diffraction_image.eps". Vous pouvez déjà constater la facilité avec laquelle on peut tracer ce type de figure avec python et matplotlib. En effet, seulement une dizaine de lignes de code sont nécessaire pour obtenir le résultat recherché. Difficile dans ce cas de faire beaucoup mieux !.

Figure 2: Un autre exemple avec une échelle de couleur différente

from numpy import *

import matplotlib.pyplot as plt
import matplotlib.cm as cm

x,y,z = loadtxt("output_diffraction", unpack=True)

t=reshape(z,(601,601))

plt.imshow(t, interpolation='bilinear', 
              cmap=cm.gist_gray, 
              origin='lower', 
              extent=[-300,300,-300,300])

plt.xticks(size = 8)
plt.yticks(size = 8)

plt.xlabel(r'$X.10^3$',fontsize=10)
plt.ylabel(r'$Y.10^3$',fontsize=10)
plt.title('Diffraction de Fraunhofer \n pour une ouverture rectangulaire',fontsize=12, color='r')

plt.savefig("diffraction_image.eps")

Nous allons à présent détailler les différentes lignes de commande
du script "diffraction.py" presenté ci-dessus. La première étape consiste à appeler tous les modules python dont on va avoir besoin pour tracer notre figure. Si nous voulons utiliser par exemple des matrices pour stocker
nos données, il est nécessaire d'importer des modules de la bibliothèques numpy. Pour cela, il existe plusieurs façon de proceder. Dans notre exemple, nous avons choisi d'importer l'ensemble des modules de numpy en tapant la commande suivante: from numpy import * . D'autre part, si nous voulons tracer notre figure nous avons également besoin de modules de la bibliothèques matplotlib. Pour créer et modifier notre image, nous avons par exemple besoin du module matplotlib pyplot. De même, pour utiliser une échelle de couleur nous avons besoin du module matplotlib nommé cm. Afin d'importer ces deux modules, il suffit alors d'utiliser les deux commandes suivantes:
import matplotlib.pyplot et import matplotlib.cm.
Voila pour l'étape essentielle consistant à importer les modules nécessaires pour tracer notre image.

Avant de vous présenter comment utiliser les modules que nous venons d'importer, nous allons vous apprendre une astuce qui permet d'ameliorer la lisibilité des scripts grâce à la commande as. En effet, cette dernière permet de remplacer un nom de variable trop long par un nom plus court de votre choix. Dans notre script par exemple, matplotlib.pyplot et matplotlib.cm ont été remplacés respectivement par plt et cm. Désormais, quand nous aurons besoin dans notre script de faire appel à ces modules il suffira alors de taper plt et cm au lieu de matplotlib.pyplot et matplotlib.cm.

Figure 3: Echelles de couleurs (d'après le site de scipy )

Nous pouvons maintenant nous attaquer à notre figure de diffraction.
Pour cela, la première chose à faire est de récupérer les données du fichier
"output_diffraction" que nous avons décrit au début de cette fiche technique. Afin de stocker les données des colonnes X, Y et Z
dans des matrices distinctes nous avons utilisé la fonction numpy: loadtxt(), avec comme argument unpack=True. Nous disposons alors de trois matrices x, y et z de dimension (361201,1) ou 361201 est le nombres de lignes du fichier output_diffraction. Pour tracer une image avec matplotlib, nous allons utiliser la fonction imshow(). Cette dernière (voir notes de bas de page) nécéssite, au minimum, comme argument une seule matrice de dimensions (m,n) où m et n sont respectivement le nombre de données suivant l'axe des abscisses et des ordonnées. Par conséquent, les matrices x et y ne vont pas nous servir pour tracer notre image, par contre il est nécéssaire de modifier la forme de la matrice z pour l'adapter à la fonction imshow. Cependant, il est donc indispensable de savoir comment nos données ont été sauvegardées dans le fichier output_diffraction. Dans notre cas, c'est relativement facile car nous avons la même resolution et les mêmes valeurs limites suivant l'axe des abscisses et des ordonnées. Il suffit donc de transformer la matrise z de dimension (361201,1) en une matrice de dimension (601,601) (on a bien 601 * 601 = 361201). Pour modifier la forme de la matrice z, il faut alors recourir à la fonction numpy: reshape, et lui préciser en argument les dimensions désirées ((601,601) dans notre cas). Une fois la matrice z redimensionnée correctement, nous pouvons alors appliquer la fonction imshow en lui fournissant d'autres arguments optionnels comme par exemple l'échelle de couleur utilisée: cmap=cm.gist_gray ou encore les limites minimum et maximum sur l'axe des abscisses et des ordonnées: extent=[-300,300,-300,300].(Remarque: dans une future fiche technique nous vous présenterons de manière plus détaillée les possibilités offertes par la fonction imshow).

Finalement, afin d'améliorer notre figure, nous pouvons par exemple grossir les labels des axes x et y à l'aide des fonctions plt.xticks() et plt.yticks() avec comme argument size = 8. Nous pouvons également rajouter un titre de couleur rouge à notre image grâce à la fonction: plt.title() avec comme arguments color='r' (pour la couleur) et fontsize=12 (pour la taille du titre). (Astuce: Si votre titre est trop long, comme dans notre exemple, vous pouvez le diviser sur plusieurs lignes. Il suffit pour cela d'utiliser \n pour indiquer un passage à la ligne). Pour sauvegarder notre figure, il y a la fonction: plt.savefig("diffraction_image.eps") qui permet de sauvegarder celle-ci sous differents formats. Dans notre exemple nous avons choisi
de sauvegarder par exemple notre figure sous le format eps.

Vous disposez maintenant de tous les outils nécessaire pour reproduire ce type de figure. Sachez que vous pouvez aussi modifier très simplement l'échelle de couleur (rendez-vous sur le site de
scipy
pour découvrir l'ensemble des échelles de couleur disponible).
Pour modifier la couleur de notre graphique il suffit, en effet, de remplacer gist_gray dans le fichier diffraction.py par le nom de l'échelle de couleur recherchée (figure 3). Si vous ne trouvez pas votre bonheur parmi les différentes échelles de couleurs, pas de problème,
sur la page de scipy vous trouverez également comment construire votre propre échelle de couleur !.


Card image cap
profile-image
Daidalos

Hi, I am Ben.

I have developed this web site from scratch with Django to share with everyone my notes. If you have any ideas or suggestions to improve the site, let me know ! (you can contact me using the form in the welcome page). Thanks!