14. Difracción en campo lejano

Autor:Luis Miguel Sánchez Brea
Revisor:José Luis Vilas Prieto

Herramientas utilizadas en este tutorial:

  • numpy: manipulación de datos
  • scipy: Herramientas matemáticas

Archivos necesarios para esta sección:

  • camposXY.py. Archivo con las funciones principales camposXY.py
  • fuentesXY.py. Archivo con las funciones principales fuentesXY.py
  • mascarasXY.py. Archivo con las funciones principales mascarasXY.py

Descarga de archivos:

14.1. Introducción

En esta sección analizaremos la difracción en campo lejano bajo la aproximación de Fraunhofer.

El efecto de las interferencias surgen directamente de que las ecuaciones de Maxwell son lineales en los campos eléctricos y magnéticos. Supongamos que \mathbf{E}_{1} y \mathbf{E}_{2} son soluciones. Entonces

z\gg\frac{\pi a^{2}}{\lambda}

donde a es el tamaño máximo del elemento difractor. Bajo esta aproximación, el campo difractado se puede calcular como una integral

\mathbf{E}(x,y,z)=\frac{e^{ik(z+\frac{x^{2}+y^{2}}{2z})}}{i\lambda z}\iint\mathbf{E}_{0}(\xi,\eta)e^{-i\frac{k}{z}(x\xi+y\eta)}d\xi d\eta.

donde \mathbf{E}_{0}(\xi,\eta) es el campo justo a la salida del elemento difractor.

La aproximación más usual para este campo es considerar que se obtiene como el producto del campo incidente \mathbf{E}_{in}(\xi,\eta) por el coeficiente de transmisión del máscara t(\xi,\eta)\mathbf{E}_{in}(\xi,\eta)

\mathbf{E}_{out}(\xi,\eta)=t(\xi,\eta)\mathbf{E}_{in}(\xi,\eta).

La gran ventaja de esta ecuación es que se puede escribir como una transformada de Fourier, que es una operación bastante conocida en matemáticas

\mathbf{E}(x,y,z)=\frac{e^{ik(z+\frac{x^{2}+y^{2}}{2z})}}{i\lambda z}TF\left[\mathbf{E}_{0}(\xi,\eta)\right].

Como el primer término delante de la transformada de Fourier es casi constante para un plano z determinado, se suele eliminar.

14.2. Difracción por un cuadrado

Vamos a calcular mediante implementación de código de Python el campo difractado a partir de una máscara cuadrada. Se observa el perfil con la típica figura de sinc^{2}(x)

#!/usr/local/bin/python
# -*- coding: utf-8 -*-
#------------------------------------
# Autor:	Luis Miguel Sanchez Brea
# Fecha		2013/10/24 (version 1.0)
# Licencia:	GPL
# Objetivo:	Ejemplos de difraccion en campo lejano
#-------------------------------------

#Anadimos las direcciones de las clases que se utilizan
import sys
sys.path.append('../')
#Se cargan las clases que se utilizan
from fuentesXY import *
from mascarasXY import mascaraXY, dibujar_varios_campos

#Datos de tamanos predeterminados
tamano = 250 * um
npuntos = 1024
x0 = sp.linspace(-tamano * um, tamano * um, npuntos)
y0 = sp.linspace(-tamano * um, tamano * um, npuntos)

#Longitud de onda predeterminada
lambda0 = 0.6238 * um

def difraccion_cuadrado():
		#Se carga la clase fuentes
	u1 = fuenteXY(x = x0, y = y0, wavelength = lambda0)
		#Condicion de onda plana
	u1.onda_plana(A = 1, theta = sp.pi / 2, phi = 0 * grados)
		#Trabajaremos con la clase mascaras
	t1 = mascaraXY(x = x0, y = y0, wavelength = lambda0)
	#Mascara cuadrada
	t1.cuadrado(r0 = (0 * um, 0 * um), size = (15 * um, 15 * um), angulo = 0 * grados)
		#Campo por mascara
	u2 = u1 * t1
	#Transformada de Fourier
	u3 = u2.fft(quitar0 = False)
		#Representacion
	dibujar_varios_campos(campos=(t1,u3), titulos=('mascara','campo lejano'), logaritmico=True, normalizar='maximo')
	plt.axis([u3.x.min()/3, u3.x.max()/3, u3.y.min()/3, u3.y.max()/3])
	punto1=(u3.x.min(),0)
	punto2=(u3.x.max(), 0)
	u3.dibujar_perfil(punto1,punto2, normalizar='maximo')


difraccion_cuadrado()
plt.show()

(Source code)

Tras haber ejecutado el código se obtiene la máscara y el patrón de intensidades, así mismo se muestra un perfil de intensidad.

14.3. Difracción por una rendija

En este ejemplo calcular el campo difractado Por una rendija. Es muy parecido al cuadrado, pero en una de las direcciones colapsa a una línea, pues la transformada de Fourier de un campo plano (en la dirección y) es una delta de Dirac.

def difraccion_rendija():
        #Clase fuentes
	u1 = fuenteXY(x = x0, y = y0, wavelength = lambda0)
        #Iluminacion de onda plana
	u1.onda_plana(A = 1, theta = sp.pi / 2, phi = 0 * grados)
	#Clase mascaras
	t1 = mascaraXY(x = x0, y = y0, wavelength = lambda0)
        #Rendija
	t1.rendija(x0 = 0, size = 5 * um, angulo = 0 * grados)
        #Campo transmitido
	u2 = u1 * t1
        #Campo difractado
	u3 = u2.fft(quitar0 = False)
        #Representacion
	dibujar_varios_campos(campos=(u2, u3),titulos=('mascara', 'fft'), 
		titulo='tamano', logaritmico = True, normalizar = 'maximo' )
	plt.set_cmap("gray")
	#perfiles
	punto1=(u3.x.min()/2,0)
	punto2=(u3.x.max()/2,0)
	h, z_perfil, punto1, punto2=u3.dibujar_perfil(punto1,punto2, npixels=npuntos, \
 normalizar = 'maximo')

Tras ejecutar el código se obtiene la máscara y el patrón de intensidades, así mismo se muestra un perfil de intensidad.

(Source code)

14.4. Difracción por un círculo

Se calcula el campo difractado por una máscara circular. El resultado muestra el perfil con la típica figura de J_{0}^{2}(x).

def difraccion_circulo():
        #Clase fuentes
	u1 = fuenteXY(x = x0, y = y0, wavelength = lambda0)
        #Iluminacion onda plana
	u1.onda_plana(A = 1, theta = sp.pi / 2, phi = 0 * grados)
        #Clase mascaras
	t1 = mascaraXY(x = x0, y = y0, wavelength = lambda0)
        #Mascara
	t1.circulo(r0 = (0 * um, 0 * um), radius = (15 * um, 15 * um), angulo = 0 * grados)
        #Campo transmitido
	u2 = u1 * t1
	#Campo difractado
	u3 = u2.fft(quitar0 = False)
        #Representacion
	punto1=(u3.x.min()/5,0)
	punto2=(u3.x.max()/5,0)
	dibujar_varios_campos(campos=(t1,u3), titulos=('mascara','campo lejano'), logaritmico=True, normalizar='maximo')
	plt.axis([u3.x.min()/3, u3.x.max()/3, u3.y.min()/3, u3.y.max()/3])
	u3.dibujar_perfil(punto1,punto2, normalizar='maximo')

Tras ejecutar el código se obtiene la máscara y el patrón de intensidades, así mismo se muestra un perfil de intensidad.

(Source code)

14.5. Difracción por una doble rendija

Se muestra también la figura de difracción de una única rendija y se observa que es la envolvente de la doble rendija: doble rendija = difracción de una rendija + interferencia entre dos rendijas.

def difraccion_doble_rendija():
        #Clase fuentes
	u1 = fuenteXY(x = x0, y = y0, wavelength = lambda0)
        #Iluminacion onda plana
	u1.onda_plana(A = 1, theta = sp.pi / 2, phi = 0 * grados)
	#Doble rendija
	t1 = mascaraXY(x = x0, y = y0, wavelength = lambda0)
	t1.dobleRendija(x0 = 0, size = 5 * um, separacion = 20 * um, angulo = 0 * grados)
        #Campo transmitido y difractado 1
	u2 = u1 * t1
	u3 = u2.fft(quitar0 = False)

	#Rendija (para ver que es la convolucion de la doble rendija)
	t3 = mascaraXY(x = x0, y = y0, wavelength = lambda0)
	t3.rendija(x0 = 0, size = 5 * um, angulo = 0 * grados)
	#Campo transmitido y difractado 2
	u4 = u1* t3
	u5 = u4.fft(quitar0 = False)

	#Dibujar mascara y transformada
	dibujar_varios_campos(campos=(u2,u3), titulos=('mascara','fft'),  \
						logaritmico=True, normalizar='maximo')
	#Perfiles
	punto1=(u5.x.min(),0)
	punto2=(u5.x.max(),0)
	h, z_perfil, punto1, punto2=u5.perfil(punto1,punto2)
	u3.dibujar_perfil(punto1,punto2, normalizar = 'maximo')
	plt.plot(h,z_perfil/z_perfil.max(),'r',lw=2)
	plt.legend(('doble rendija', 'una rendija'))
	plt.xlim(h.min()/3,h.max()/3)
	

Tras ejecutar el código se obtiene la máscara y el patrón de intensidades, así mismo se muestra un perfil de intensidad. Nótese como la envolvente del patrón de intensidades en la pantalla es la intensidad de una única rendija.

(Source code)

14.6. Difracción por una estructura complicada: estrella

Las estructuras más complejas tienen una distribución en el plano de Fourier también más complejo. En este ejemplo la máscara ha sido una estrella, esta se ha cargado a partir de una imagen binarizada, por tanto no ha sido programada o tomada de la clase máscaraXY.

def difraccion_estrella():
	u1 = fuenteXY(x = x0, y = y0, wavelength = lambda0)
	u1.onda_plana(A = 1, theta = sp.pi / 2, phi = 0 * grados)
	t1 = mascaraXY(x = x0, y = y0, wavelength = lambda0)
	t1.imagen(nombre='estrella_pequena.png')

	u2 = u1 * t1
	u3 = u2.fft(quitar0 = False)

	dibujar_varios_campos(campos=(u2,u3), titulos=('mascara','fft'),  \
							logaritmico=True, normalizar='maximo')

Tras ejecutar el código se obtiene la máscara y el patrón de intensidades.

(Source code, png, hires.png, pdf)

../../_images/difraccion_estrella.png

14.7. Difracción por una estructura complicada: fotografía

Las estructuras más complejas tienen una distribución en el plano de Fourier también más complejo, este es el caso de una fotografía real, en la cual debido a los múltiples detalles, la transformada de Fourier se muestra como un patrón del que podría decirse que carece de orden, sin embargo conserva la información de la imagen original.

def difraccion_lena():
	u1 = fuenteXY(x = x0, y = y0, wavelength = lambda0)
	u1.onda_plana(A = 1, theta = sp.pi / 2, phi = 0 * grados)
	t1 = mascaraXY(x = x0, y = y0, wavelength = lambda0)
	t1.imagen(nombre='lena.png')

	u2 = u1 * t1
	u3 = u2.fft(quitar0 = False)

	dibujar_varios_campos(campos=(u2,u3), titulos=('mascara','fft'),  \
							logaritmico=True, normalizar='maximo')

Tras ejecutar el código se obtiene la máscara y el patrón de intensidades.

(Source code, png, hires.png, pdf)

../../_images/difraccion_lena.png

14.8. Difracción por una red de sinusoidal

La red sinusoidal tiene solamente tres frecuencias espaciales, que son las que se observan en la figura de difracción.

def difraccion_red_seno():
	#tamano de area de visualizacion
	tamano = 1000 * um
	ndatos = 512
	x0 = sp.linspace(-tamano / 2, tamano / 2, ndatos)
	y0 = sp.linspace(-tamano / 2, tamano / 2, ndatos)
	#longitud de onda
	lambda0 = 0.6238 * um

	#fuente de iluminacion
	u1 = fuenteXY(x = x0, y = y0, wavelength = lambda0);
	u1.onda_plana(A = 1, theta = 0 * grados, phi = 0 * grados)

	#mascara
	t1 = mascaraXY(x = x0, y = y0, wavelength = lambda0)
	t1.red_seno(periodo=40*um)
	u2 = u1 * t1

	u3 = u2.fft(quitar0 = False)

	u2.dibujar()
	
	punto1=(u3.x.min(),0)
	punto2=(u3.x.max(),0)
	
	u3.dibujar_perfil(punto1,punto2, normalizar='maximo', order=2)

Tras ejecutar el código se obtiene la máscara y el perfil de intensidades en la pantalla.

(Source code)

14.9. Difracción por una red de Ronchi

La red de Ronchi tiene más frecuencias espaciales, todas equidistanciadas, que son las que se observan en la figura de difracción. La altura de cada pico es el cuadrado del valor del coeficiente de Fourier I_{pico,n}=\left|a_{n}\right|^{2}.

def difraccion_red_ronchi():
	#tamano de area de visualizacio
	tamano = 1000 * um
	ndatos = 512
	x0 = sp.linspace(-tamano / 2, tamano / 2, ndatos)
	y0 = sp.linspace(-tamano / 2, tamano / 2, ndatos)
	#longitud de onda
	lambda0 = 0.6238 * um

	#fuente de iluminacion
	u1 = fuenteXY(x = x0, y = y0, wavelength = lambda0);
	u1.onda_plana(A = 1, theta = 0 * grados, phi = 0 * grados)

	#mascara
	t1 = mascaraXY(x = x0, y = y0, wavelength = lambda0)
	t1.red_ronchi( periodo = 40 * um, x0 = 0 * um, fillFactor = 0.5, angulo = 0 * grados)
	u2 = u1 * t1

	u3 = u2.fft(quitar0 = False)

	u2.dibujar()
	
	punto1=(u3.x.min(),0)
	punto2=(u3.x.max(),0)
	
	u3.dibujar_perfil(punto1,punto2, normalizar='maximo', order=2)

Tras ejecutar el código se obtiene la máscara y el perfil de intensidades en la pantalla.

(Source code)

14.10. Propiedades de la transformada de Fourier

En esta sección se analizan las propiedades matemáticas de la transformada de Fourier, a traves de la observación de la misma en el plano de Fourier.

14.10.1. Desplazamiento del objeto

En este epígrafe mostramos como desplazar un elemento difractivo, la distribución de intensidad es la misma (no la fase). Esto matemáticamente se corresponde con la propiedad:

TF[f(t-a)](\omega)=e^{-i\omega a}TF[f(t)](\omega)

Así queda patente al ejecutar el siguiente código, el cual considera la difracción por una máscara cuadrada. Las figuras muestras la máscara y su desplazamiento así como la obsercación en el plano de Fourier de sendas máscaras.

def difraccion_desplazamiento():
	u1 = fuenteXY(x = x0, y = y0, wavelength = lambda0)
	u1.onda_plana(A = 1, theta = sp.pi / 2, phi = 0 * grados)
	t1 = mascaraXY(x = x0, y = y0, wavelength = lambda0)
	t1.cuadrado(r0 = (0 * um, 0 * um), size = (15 * um, 15 * um), angulo = 0 * grados)

	t2 = mascaraXY(x = x0, y = y0, wavelength = lambda0)
	t2.cuadrado(r0 = (100 * um, 0 * um), size = (15 * um, 15 * um), angulo = 0 * grados)

	u2 = u1 * t1
	u3 = u2.fft(quitar0 = False)

	u4 = u1 * t2
	u5 = u4.fft(quitar0=False)

	dibujar_varios_campos(campos=(t1,t2), titulos=('x=0 um','x=100*um'), titulo='desplazamiento',\
     logaritmico=True, normalizar='maximo')

	dibujar_varios_campos(campos=(u3,u5), titulos=('x=0 um','x=100*um'),  \
					titulo='desplazamiento', logaritmico=True, normalizar='maximo')
     

(Source code)

14.10.2. Rotación del objeto

En este epígrafe se considera el mismo elemento difractivo del ejemplo anterior pero aplicándole una rotación, así resulta una rotación de la transformada de Fourier.

def difraccion_rotacion():
	u1 = fuenteXY(x = x0, y = y0, wavelength = lambda0)
	u1.onda_plana(A = 1, theta = sp.pi / 2, phi = 0 * grados)
	t1 = mascaraXY(x = x0, y = y0, wavelength = lambda0)
	t1.cuadrado(r0 = (0 * um, 0 * um), size = (15 * um, 15 * um), angulo = 0 * grados)

	t2 = mascaraXY(x = x0, y = y0, wavelength = lambda0)
	t2.cuadrado(r0 = (0 * um, 0 * um), size = (15 * um, 15 * um), angulo = 45 * grados)

	u2 = u1 * t1
	u3 = u2.fft(quitar0 = False)

	u4 = u1 * t2
	u5 = u4.fft(quitar0=False)

	dibujar_varios_campos(campos=(t1,t2), titulos=('0 grados','45 grados'),  \
					titulo='desplazamiento', logaritmico=True,\
     normalizar='maximo')

	dibujar_varios_campos(campos=(u3,u5), titulos=('0 grados','45 grados'),  \
					titulo='rotacion', logaritmico=True,\
     normalizar='maximo')

(Source code)

14.10.3. Haz con distinto ángulo de entrada

Si el ángulo del incidencia es variado, la posición en el plano de Fourier del orden cero de difracción se ve desplazada.

#!/usr/local/bin/python
# -*- coding: utf-8 -*-
#------------------------------------
# Autor:	Luis Miguel Sanchez Brea
# Fecha		2013/10/24 (version 1.0)
# Licencia:	GPL
# Objetivo:	Ejemplos de difraccion en campo lejano
#-------------------------------------

#anadimos las direcciones de las clases que se utilizan
import sys
sys.path.append('../')

#se cargan las clases que se utilizan
from fuentesXY import *
from mascarasXY import mascaraXY, dibujar_varios_campos

#datos de tamanos predeterminados
tamano = 250 * um
npuntos = 1024
x0 = sp.linspace(-tamano * um, tamano * um, npuntos)
y0 = sp.linspace(-tamano * um, tamano * um, npuntos)

#longitud de onda predeterminada
lambda0 = 0.6238 * um


def difraccion_haz_inclinado(haz_incidente):
	u1=haz_incidente
	t1 = mascaraXY(x = x0, y = y0, wavelength = lambda0)
	t1.cuadrado(r0 = (0 * um, 0 * um), size = (15 * um, 15 * um), angulo = 0 * grados)
	u2 = u1 * t1
	u3 = u2.fft(quitar0 = False)

	return u2, u3


u1 = fuenteXY(x = x0, y = y0, wavelength = lambda0)
u1.onda_plana(A = 1, theta = sp.pi / 2, phi = 0 * grados)
t1, fft1= difraccion_haz_inclinado(u1)

u2 = fuenteXY(x = x0, y = y0, wavelength = lambda0)
u2.onda_plana(A = 1, theta = sp.pi / 2, phi = 15 * grados)
t2, fft2= difraccion_haz_inclinado(u2)


dibujar_varios_campos(campos=(fft1,fft2), titulos=('0 grados','15 grados'), \
titulo='fft', logaritmico=True, normalizar='maximo')


plt.show()

(Source code, png, hires.png, pdf)

../../_images/difraccion_haz_inclinado.png

14.10.4. Misma máscara, distinto haz

Se compara la difracción por un máscara cuadrada bajo dos fuentes de iluminación, un haz de entrada en primer lugar considerado una onda plana y en segudno, una onda gaussiana con un tamaño comparable al elemento difractor. El resultado, muestra como en el caso del haz gausiano, la mayor parte de la energía del haz difractado se concentra en los órdenes más bajo de difracción. Mientras que en el caso de una onda plana, la energía está más repartida entre los distintos órdenes.

#!/usr/local/bin/python
# -*- coding: utf-8 -*-

#----------------------------------------------------------------------
#!/usr/local/bin/python
# -*- coding: utf-8 -*-
#------------------------------------
# Autor:	Luis Miguel Sanchez Breaje
# Fecha		2013/10/24 (version 1.0)
# Licencia:	GPL
# Objetivo:	Ejemplos de difraccion en campo lejano
#-------------------------------------

#anadimos las direcciones de las clases que se utilizan
import sys
sys.path.append('../')

#se cargan las clases que se utilizan
from fuentesXY import *
from mascarasXY import mascaraXY, dibujar_varios_campos

#datos de tamanos predeterminados
tamano = 250 * um
npuntos = 1024
x0 = sp.linspace(-tamano * um, tamano * um, npuntos)
y0 = sp.linspace(-tamano * um, tamano * um, npuntos)

#longitud de onda predeterminada
lambda0 = 0.6238 * um


def difraccion_rectangulo_onda_plana(haz_incidente):

	u1=haz_incidente

	t1 = mascaraXY(x = x0, y = y0, wavelength = lambda0)
	t1.cuadrado(r0 = (0 * um, 0 * um), size = (15 * um, 15 * um), angulo = 0 * grados)

	u2 = u1 * t1
	u2.dibujar(tipo = 'intensidad', logaritmico = False, normalizar = 'maximo')
	plt.axis([-15*um,15*um,-15*um,15*um])

	u3 = u2.fft(quitar0 = False)

	return u2, u3


u1 = fuenteXY(x = x0, y = y0, wavelength = lambda0)
u1.onda_plana(A = 1, theta = sp.pi / 2, phi = 0 * grados)
t1, fft1= difraccion_rectangulo_onda_plana(u1)

u2 = fuenteXY(x = x0, y = y0, wavelength = lambda0)
u2.haz_gauss(A = 1, r0 = (0 * um, 0 * um), w = (5 * um, 5 * um),  \
				theta = 0.*grados, phi = 0 * grados)
t2, fft2= difraccion_rectangulo_onda_plana(u2)

dibujar_varios_campos(campos=(fft1,fft2), titulos=('plana','gauss'), titulo='fft', logaritmico=True, normalizar='maximo')


plt.show()

(Source code)

14.10.5. Máscara con distinto tamaño

Considérense dos máscaras con la misma topología pero de distinto tamaño. La observación del haz difractado en el plano de Fourier cambia de escala, esto es mantiene la misma topología pero no su tamaño.

#!/usr/local/bin/python
# -*- coding: utf-8 -*-
#------------------------------------
# Autor:	Luis Miguel Sanchez Breaje
# Fecha		2013/10/24 (version 1.0)
# Licencia:	GPL
# Objetivo:	Ejemplos de difraccion en campo lejano
#-------------------------------------

#anadimos las direcciones de las clases que se utilizan
import sys
sys.path.append('../')

#se cargan las clases que se utilizan
from fuentesXY import *
from mascarasXY import mascaraXY, dibujar_varios_campos

#datos de tamanos predeterminados
tamano = 250 * um
npuntos = 1024
x0 = sp.linspace(-tamano * um, tamano * um, npuntos)
y0 = sp.linspace(-tamano * um, tamano * um, npuntos)

#longitud de onda predeterminada
lambda0 = 0.6238 * um


def difraccion_tamano(anchura):
	u1 = fuenteXY(x = x0, y = y0, wavelength = lambda0)
	u1.onda_plana(A = 1, theta = sp.pi / 2, phi = 0 * grados)
	t1 = mascaraXY(x = x0, y = y0, wavelength = lambda0)
	t1.cuadrado(r0 = (0 * um, 0 * um), size = (anchura,anchura), angulo = 0 * grados)

	u2 = u1 * t1
	u3 = u2.fft(quitar0 = False)

	return t1, u3


fft_pequeno, t1=difraccion_tamano(5*um)
fft_grande, t2 =difraccion_tamano(15*um)

dibujar_varios_campos(campos=(t1,t2), titulos=(r'$5\,\mu m$', r'$15\,\mu m$'),  \
		titulo='desplazamiento', logaritmico=True, normalizar='maximo')

dibujar_varios_campos(campos=(fft_pequeno,fft_grande),titulos=(r'$5\,\mu m$', r'$15\,\mu m$'),
		titulo='tamano', logaritmico = True, normalizar = 'maximo' )

plt.show()

(Source code)

14.10.6. Distinta longitud de onda

Si se considera una misma máscara pero distintas longitudes de onda de luz incidente en el plano de Fourier se observa que la distribución de intensidad es la misma, pero no su tamaño. Este hecho queda patente en las figuras ejemplo fruto de ejecutar el código de abajo. Si tuvieran distinta escala se verían diferente.

#!/usr/local/bin/python
# -*- coding: utf-8 -*-
#------------------------------------
# Autor:	Luis Miguel Sanchez Breaje
# Fecha		2013/10/24 (version 1.0)
# Licencia:	GPL
# Objetivo:	Ejemplos de difraccion en campo lejano
#-------------------------------------

#anadimos las direcciones de las clases que se utilizan
import sys
sys.path.append('../')

#se cargan las clases que se utilizan
from fuentesXY import *
from mascarasXY import mascaraXY, dibujar_varios_campos

#datos de tamanos predeterminados
tamano = 250 * um
npuntos = 1024
x0 = sp.linspace(-tamano * um, tamano * um, npuntos)
y0 = sp.linspace(-tamano * um, tamano * um, npuntos)


def difraccion_cuadrado(longitud_onda):
	u1 = fuenteXY(x = x0, y = y0, wavelength = longitud_onda)
	u1.onda_plana(A = 1, theta = sp.pi / 2, phi = 0 * grados)
	t1 = mascaraXY(x = x0, y = y0, wavelength = longitud_onda)
	t1.cuadrado(r0 = (0 * um, 0 * um), size = (15 * um, 15 * um), angulo = 0 * grados)

	u2 = u1 * t1
	u3 = u2.fft(quitar0 = False)

	return u3

s1=difraccion_cuadrado(0.405*um)
s2=difraccion_cuadrado(0.6328*um)
dibujar_varios_campos(campos=(s1,s2), titulos=(r'$0.405\,\mu m$', r'$0.6238\,\mu m$'),  \
						logaritmico=True, normalizar='maximo')

plt.show()

(Source code, png, hires.png, pdf)

../../_images/difraccion_longitud_onda.png