#JCourtin 02/2016
#modified 12/2016

from matplotlib import pyplot as plt
from numpy import *
from cmath import *

"""
On note x la position sur le diaphragmme et X celle sur l'écran :

1 - on crée l'ensemble de émetteurs sur le diaphragmme (source de Fresnel)
2 - on crée les positions de calcul sur l'écran

3 - En chacun des points de l'écran on fait la somme de Fresnel des ondes émises par toutes les sources secondaires du diaphragmme. (c'est long !)


RQ : les tableaux ou diamètres d'ouverture du diaphragmme sont tous impairs
     car il y a une cellule centrale et un nombre symétrique de chaque coté.



a - Le TD se propose de tester le code sur le cas de la diffraction par une ouverture rectangulaire,
    Vous devez en particulier retourver les interfranges connus selon x et selon y.

b - Vous pouvez ensuite essayer d'autres résolutions :
    NX,NY pour le diaphragmme et MX MY pour l'écran
    
c - Enfin vous pouvez tester d'autres formes de diaphragmmes.




"""


##########################   Ne pas modifier   #################################


### Fonctions diaphragmme 


    #Dans tous les cas les fonctions suivantes créent et renvoient :
    #un tableau numpy (fente) qui vaut 1. quand la lumière passe 
    #et 0. quand elle ne passe pas.
    
    #vous ne ferez que ouvertureRectangulaire dans un premier temps.
    
    #Vous pouvez tracer votre diaphragmme pour le vérifier avec matshow(tableauNumpy):
    #plt.close();    plt.matshow(image);      plt.show()
    #vérifier le centrage sur de petites tailles.
    
    

#ouverture cirulaire
def Disque(NX,NY, diam):   #Attention a est le diamètre en pixel => impair
    #ouverture circulaire centrée de diamètre diam
    return fente


#ouverture fente infini
def fenteInfinie(NX,NY, ax):    
    #fente verticale centrée de largeur ax
    return fente
    
    
    
def ouvertureRectangulaire(NX,NY, ax, ay):    
    #ouverture rectangulaire centrée de ax par ay.
    return fente




#Trous de Young
def doubleDisque(Nx, Ny, diam):       #exmple de cas plus compliqué
    a=diam//2                         #deux trous
    if (2*a > Nx//3):
        return "PB"
    fente=zeros((NY,NX))
    
    XC1=NX//6; XC2=5*NX//6 #il y a deux centres ....
    
    YC=NY/2
    
    for XC in [XC1, XC2]:
        for i in range(NY):
            for j in range(NX):
                dist=((i-YC)**2 + (j-XC)**2)**0.5
                if (dist < a):
                    fente[i,j]=1.

    return fente

################################################################################


#                              *** Partie TD *** 

## 0 caracteristiques physiques
LOnde = 500.e-9 #lambda
k0=2*pi/LOnde   #vecteur onde

D = 10.   #metre  -> distance ecran
L = 0.01  #metre  -> echelle physique du diaphragme (!!! il y a 2 directions !!!)


## 1 Construction du diaphragmme

#taille matrice
NX=10+1     #nombre impair => 1 cellule au centre
NY=20+1     #Ne pas modifier ces valeurs dans un premier temps

dx=L/NX   #taille pixel (physique)
dy=L/NX   #même échelle


ax=11      #fente -> ouverture fente en pixel (!!! diametre ou largeur !!!)
ay=21

InterX=??    #ODG en mètre de l'interfrange
InterY=??  


#Choix du diaphragmme :

#ouverture fente infinie : a impair
#----------------------------------
#fente = fenteInfinie(NX, NY, ax)


#ouverture rectangulaire :
#-------------------------
fente=ouvertureRectangulaire(NX, NY, ax, ay)

#ouverture circulaire :
#----------------------
#fente = Disque(NX,NY, ax)


#trous de young :
#----------------
#fente = doubleDisque(NX, NX, ay)



#positions physiques x et y des cellules sur le diaphragme (faire un schéma)
x=[#Compréhension de liste --> ??? for k in range(NX)]
y=[#idem sur y ]   #vérifier les bornes !


#Objet numpy pour le diaphragme : matrice de tuple (y, x, fente(x,y))
#
#soit la nature de l'objet :   liste de liste (matrice) contenant en tout point
#                              un tuple (y, x, 0. ou 1.)

diaph = #Générer le tableau numpy matrice à l'aide des compréhensions de liste.)




## 2 Construction de l'écran

#Caracteristiques de l'image à produire :

MX=60      #toujours impair => 1 cellule au centre
MY=60      #Ne pas modifier ces valeurs dans un premier temps

#reduire à 30x30 si le temps de calcul est trop long.  [ t < 10 secondes ]

image =  ???  #A compléter: on veut initialiser la matrice avec des zeros

#La taille physique de l'écran est fixée en terme de nombre de fois l'interfrange :

TX=6*InterX   # position de calcul sur l'écran
TY=6*InterX   #même dimension

dX=?
dY=?

X=[#Compréhension de liste --> ??? for k in range(MX)]  #positions sur l'écran
Y=[#idem sur Y  : vérifier les bornes !!!


## 3 Calcul de la diffraction

for k in range(MY):
    for l in range(MX):
         
        #On veut sommer les amplitude de tous les points sources
        #soit diaph[i,j,2]*exp(1j*k0/D*(Y[k]*diaph[i,j,0] + X[l]*diaph[i,j,1]))
        
        amplitude =  ??
    
        #Puis calcul de l'intensité résultante.
        image[k,l]=??  # A compléter


#Représentation de l'intersité sur l'écran
#plt.close()
#????
#plt.show()


"""
#Intersité sur l'écran pour y=0 (coupe transverse)

????  #Vérifier que vous retrouver les bons interfranges.
plt.show()

"""