Indice de réfraction des verres optiques

1. Dispersion des verres

Les verres transparents pour la lumière visible sont caractérisés par leur indice de réfraction. Cet indice dépendant de la longueur d'onde, on le mesure pour les raies de référence de Fraunhofer (raies du spectre solaire). Les plus utilisées sont données dans le tableau suivant ([1]).

Nom	λ (nm)
C	656.3
D	589.3
d	587.6
F	486.1

La variation de l'indice du verre avec la longueur d'onde est caractérisée par le nombre d'Abbe, appelé aussi constringence du verre :

$$V_D=\frac{n_D-1}{n_F-n_C}$$

Pour modéliser la dispersion d'un verre, il suffit (en première approche) de connaitre l'indice pour la raie D et le nombre d'Abbe. Le tableau suivant donne ces valeurs pour quelques verres :

Nom	nD	VD
Crown C	1.5125	60.5
Crown flint CF1	1.5286	51.6
Light flint LF1	1.5725	42.5
Dense flint DF1	1.605	38
Extra dense flint EDF3	1.72	29.3

Ces données sont suffisantes pour déterminer les conditions d'achromatisme des systèmes optiques mais ne permettent pas de modéliser les spectres secondaires résiduels, qui en général ne sont pas négligeables. Une modélisation plus précise nécessite la connaissance des indices pour différentes raies.

Pour calculer l'indice à une longueur d'onde quelconque du spectre visible, on peut utiliser le modèle de Cauchy :

$$n\left(\lambda \right)=A+\frac{B}{{\lambda }^2}$$

Les deux constantes s'expriment en fonction de l'indice n_D et du nombre d'Abbe :

$$\begin{array}{cc}\hfill & B=\frac{n_D-1}{V_D(\frac{1}{{\lambda }_F^2}-\frac{1}{{\lambda }_C^2})}\hfill \\ \hfill & A=n_D-\frac{B}{{\lambda }_D^2}\hfill \end{array}$$

2. Module python

Le module IndiceVerre.py définit une classe qui permet de calculer l'indice d'un verre en fonction de la longueur d'onde, à l'aide de la formule de dispersion de Cauchy. Le constructeur prend en argument l'indice de la raie D et le nombre d'Abbe.

from numpy import zeros
            
class IndiceVerre:
    def __init__(self,nD,VD):
        self.nD=nD
        self.VD=VD
        lC=656.3
        lD=589.3
        lF=486.1
        self.B = (nD-1)/(VD*(1/(lF*lF)-1/(lC*lC)))
        self.A=nD-self.B/(lD*lD)
        self.n = nD
    def indice(self,Lambda):
        self.n = self.A+self.B/(Lambda*Lambda)
        return self.n
    def indiceArray(self,Lambda):
        s = Lambda.size
        na = zeros(s,dtype=float)
        for k in range(s):
            na[k] = self.indice(Lambda[k])
        return na
    def negatif(self):
        self.A = -self.A
        self.B = -self.B
        self.n = -self.n
            

La classe suivante permet de définir l'indice du vide avec la même interface :

class IndiceVide:
    def __init__(self):
        self.n = 1.0
    def indice(self,Lambda):
        return self.n
    def negatif(self):
        self.n = -1
            

Exemple : tracé de l'indice en fonction de la longueur d'onde.

from pylab import *
from IndiceVerre import *
n1 = IndiceVerre(1.51,60)
n2 = IndiceVerre(1.60,38)
Lambda = arange(400,700,1)
n1a = n1.indiceArray(Lambda)
n2a = n2.indiceArray(Lambda)
figure()
plot(Lambda,n1a,color='r',label='Crown')
plot(Lambda,n2a,color='b',label='Dense flint')
xlabel('lambda (nm)')
ylabel('n')
legend()
grid(True)
            

plotA.pdf

Des données plus précises sur les verres sont obtenues dans le catalogue Shott et Ohara. Les classes suivantes permettent d'accéder aux données de quelques verres commerciaux désignés par leur nom.

class Verre:
    def __init__(self,nd,nF,nC):
        self.n = {}
        self.n['d'] = nd # raie d 587 nm
        self.n['F'] = nF # raie F 486 nm
        self.n['C'] = nC # raie C 656 nm
        self.signe = +1
    def indice(self,raie):
        return self.n[raie]*self.signe
    def negatif(self):
        self.signe = -self.signe
    def clone(self):
        v = Verre(self.n['d'],self.n['F'],self.N['C'])
        v.signe = self.signe
        return v
class Vide(Verre):
    def __init__(self):
        self.n = {}
        self.n['d'] = 1.0 # raie d 587 nm
        self.n['F'] = 1.0 # raie F 486 nm
        self.n['C'] = 1.0 # raie C 656 nm
        self.signe = +1
class CatalogueVerre:
    def __init__(self):
        self.verre = {}
        self.verre['N-BK7'] = Verre(1.51680,1.522374,1.51432)
        self.verre['N-KZFS4'] = Verre(1.61336,1.623005,1.60922)
        self.verre['F5'] = Verre(1.60342,1.614617,1.59875)
        self.verre['N-FK51A'] = Verre(1.48656,1.4906,1.49088)
        self.verre['S-FPL53'] = Verre(1.4388,1.442,1.4373)