Consideremos el sistema de dos rendijas separadas una distancia $a$ de la figura siguiente, que son iluminadas por la luz procedente de una fuente casi puntual $S$ de radiación monocromática de longitud de onda $\lambda$. A una cierta distancia $D$, tal que $D>>a$, del plano que contiene a la doble rendija, se coloca una pantalla sobre la que se realizan observaciones. El campo eléctrico en el punto $P_h$ de la pantalla vendrá dado por la superposición coherente de las ondas procedentes de ambas rendijas.
$$E_p(x) = E_1+E_2 = \frac{E_0}{r_1} e^{i(\omega t -kr_1)} + \frac{E_0}{r_2} e^{i(\omega t -kr_2)}$$La distribución de irradiancia que se observa en un punto $P_h$ de la pantalla vendrá dada por la siguiente expresión. Visualmente en la pantalla se observará algo similar a lo mostrado en la figura siguiente.
$$I_P(x) \propto |E_0|^2\left[\frac{1}{r_1^2}+\frac{1}{r_2^2}+\frac{1}{r_1r_2}\cos k\left(r_2-r_1\right)\right]$$El tercer término en la ecuación anterior es el que modula la irradiancia en la pantalla. Así en un punto $P_h$ de la pantalla habrá un máximo de irradiancia si se verifica la siguiente condición.
$$ k·\frac{a·x}{D} = 1 $$esto es,
$$\frac{kax}{D}=2m\pi, \,\,\,\,\,\,\,\, \mathrm{donde} \,\,\,\,\,\,\,\, m=0,\,\pm 1,\,\pm 2...,$$Los máximos ocurren en los puntos:
$$x =m \frac{\lambda D}{a}$$y son una sucesión de franjas paralelas al eje $Z$ y equidistantes. La distancia que hay entre dos máximos o mínimos de interferencia, $Int$, se denomina interfranja y su valor viene dado por la expresión siguiente.
$$Int = \frac{\lambda D}{a}$$Hay diferentes dispositivos que son equivalentes al sistema de dos rendijas originariamente empleado por Thomas Young. Aqui vamos a considerar el dispositivo llamado biprisma de Fresnel, el cual nos permitirá variar fácilmente la separación entre las rendijas o fuentes secundarias.
En la figura siguiente se muestra cómo el biprisma produce dos fuentes secundarias de radiación equivalentes a las dos rendijas del dispositivo de Young que se ha descrito anteriormente. La luz que emerge por la parte superior del biprisma lo hace tal como si procediera de $S_1$, mientras que la parte del haz refractada por la parte inferior se propaga como si procediera de $S_2$. Por lo tanto, a la derecha del biprisma tenemos la superposición de dos ondas esféricas procedentes de $S_1$ y $S_2$, respectivamente. El plano donde se encuentran estas fuentes virtuales es equivalente al plano de las rendijas en el experimento de Young.
El dispositivo experimental con el que vamos a trabajar consiste en un láser de He-Ne, un objetivo de microscopio, un biprisma y una pantalla de observación situada al final del banco óptico. La luz procedente de láser se hace incidir sobre el objetivo de microscopio, $OM$, cuya función consiste en focalizar el haz de luz y obtener así una fuente casi puntual, $S$, como se muestra en la figura.
A continuación se presenta una simulación de la primera parte de la práctica a llevar a cabo en el laboratorio. Nuestro objetivo es hallar la longitud de onda $\lambda$ de la radiacion que ilumina el Biprisma de Fresnel utilizando la expresion ya mencionada anteriormente,
$$Int = \frac{\lambda D}{a} \Rightarrow \lambda = \frac{Int a}{D}$$Para ello, primero mediremos la interfranja del patron de interferencias generado cuando iluminamos con una fuente puntual el Biprisma de Fresnel para una distancia de trabajo $D$. A continuacion, mediremos el valor de la separacion entre las fuentes virtuales $a$ y utilizaremos la anterior expresion para obtener $\lambda$.
En primer lugar, se presenta a la izquierda una un esquema del montaje experimental: fuente puntual, biprisma de Fresnel (en rojo) y pantalla donde se visualizan las franjas de interferencia producidas por el biprisma. La distancia entre la fuente y el biprisma puede ser modificada moviendo el desplazador que se muestra justo encima de este esquema. A la derecha, se muestra el patron de interferencias (completo y una imagen ampliada de 6 mm de longitud en la zona central del patron), y el valor de la interfranja para la distancia fuente-biprisma fijada. Moviendo el desplazador, se puede observar como cambia el patron y el valor de la interfranja asociado.
In [1]:
import warnings
warnings.filterwarnings('ignore')
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
plt.style.use('bmh')
import ipywidgets as widgets
from IPython.display import display
import io
import base64
from IPython.display import clear_output
#Datos fijos
###################33
D = 3
Lambda = 6.32e-7 # longitud de onda de la radiación de 500 nm
k = 2.0*np.pi/Lambda
n = 1.33 # agua
alpha = 0.7*np.pi/180
y0 = 10
yrepres = 14 # in mm
###########################3
I1 = 1 # Consideramos irradiancias normalizadas a un cierto valor.
I2 = 1
fig,ax = plt.subplots(1,1)
ax.plot(0,0,'o',lw=2)
ax.set_xlim(-0.1,D+0.1)
ax.set_ylim(-yrepres*1.5,yrepres*1.5)
ax.set_xlabel("x (m)")
ax.set_ylabel("y (mm)")
ax.set_title('Esquema del montaje experimental')
line1, = ax.plot(np.linspace(-1,D,50),np.zeros(50),'k')
buf = io.BytesIO()
plt.savefig(buf, format='png')
buf.seek(0)
figwidg = widgets.HTML("""<img src='data:image/png;base64,{}'/>""".format(base64.b64encode(buf.getvalue()).decode('ascii')))
plt.close(fig)
fig2,ax2 = plt.subplots(1,1)
ax2.set_xlabel("x (mm)")
ax2.set_ylabel("y (mm)")
#ax2.set_xlim(0,x.max()*1e3)
#ax2.set_ylim(-yrepres,yrepres)
ax2.set_title('Pantalla')
ax2.pcolormesh(np.zeros((500,500)))
buf2 = io.BytesIO()
plt.savefig(buf2, format='png')
buf2.seek(0)
figwidg2 = widgets.HTML("""<img src='data:image/png;base64,{}'/>""".format(base64.b64encode(buf2.getvalue()).decode('ascii')))
#figbox = widgets.HBox([figwidg,figwidg2])
plt.close(fig2)
clear_output()
fig3,ax3 = plt.subplots(1,1)
ax3.set_ylabel("y (mm)")
ax3.set_title('Zoom (3 mm)')
ax3.pcolormesh(np.zeros((50,50)))
buf3 = io.BytesIO()
plt.savefig(buf3, format='png')
buf3.seek(0)
figwidg3 = widgets.HTML("""<img src='data:image/png;base64,{}'/>""".format(base64.b64encode(buf3.getvalue()).decode('ascii')))
figbox = widgets.HBox([figwidg,figwidg2,figwidg3])
plt.close(fig3)
clear_output()
#########
Interfwidg = widgets.FloatText(0,description='Int. (mm)',color='#C13535')
def changeBiprism(x0=0.1):
a = 2*x0*np.tan((n-1)*alpha) #separacion entre fuentes virtuales
interfranja = Lambda*D/a
xlimit = (D-x0)*np.tan((n-1)*alpha) # distancia desde el eje que ocupa el patron de interferencias
Pasoespacial = interfranja/20
xpantalla = np.linspace(-xlimit*1.2,xlimit*1.2,round(xlimit/Pasoespacial))
X,Y = np.meshgrid(xpantalla,xpantalla)
delta = (k*a*X/D)
Itotal = I1 + I2 + (2.0*np.sqrt(I1*I2)*np.cos(delta))*(np.abs(X)<xlimit)
figwidg.observe(repsetup(x0),names='new')
figwidg2.observe(repfringes(xpantalla,Itotal),names='new')
figwidg3.observe(repzoom(xpantalla,Itotal),names='new')
Interfwidg.observe(updateInterf(interfranja),names='new')
return
def updateInterf(interfranja):
Interfwidg.value=round(interfranja*1e3,2)
return
def repsetup(x0):
fig,ax = plt.subplots(1,1,figsize=(7,5))
ax.plot(0,0,'o',lw=2)
ax.set_xlim(-0.1,D+0.1)
ax.set_ylim(-yrepres*1.5,yrepres*1.5)
ax.set_xlabel("x (m)")
ax.set_ylabel("y (mm)")
ax.set_title('Esquema del montaje experimental')
ax.plot(np.linspace(-1,D,50),np.zeros(50),'k')
ax.vlines(x0,-y0,y0,'r',lw=2)
ax.vlines(D,-y0*3,y0*3,lw=4)
ax.plot(np.linspace(x0,x0+.02,D),(-y0/.02)*np.linspace(x0,x0+.02,D) + y0*(1+x0/.02),'r',lw=2)
ax.plot(np.linspace(x0,x0+.02,D),(y0/.02)*np.linspace(x0,x0+.02,D) - y0*(1+x0/.02),'r',lw=2)
buf = io.BytesIO()
plt.savefig(buf, format='png')
buf.seek(0)
clear_output()
figwidg.value ="""<img src='data:image/png;base64,{}'/>""".format(base64.b64encode(buf.getvalue()).decode('ascii'))
clear_output()
plt.close(fig)
return
def repfringes(x,Itotal):
fig2,ax2 = plt.subplots(1,1,figsize=(3,5))
ax2.set_ylabel("y (mm)")
ax2.set_xlim(0,x.max()*1e3)
ax2.set_ylim(-yrepres,yrepres)
ax2.set_title('Pantalla')
ax2.pcolormesh(x*1e3,x*1e3,Itotal.T,cmap = 'gray',vmin=0,vmax=4)
buf2 = io.BytesIO()
plt.savefig(buf2, format='png')
buf2.seek(0)
clear_output()
figwidg2.value ="""<img src='data:image/png;base64,{}'/>""".format(base64.b64encode(buf2.getvalue()).decode('ascii'))
clear_output()
plt.close(fig2)
return
def repzoom(x,Itotal):
fig3,ax3 = plt.subplots(1,1,figsize=(3,5))
ax3.set_ylabel("y (mm)")
ax3.set_xlim(0,x.max()*1e3)
ax3.set_ylim(-3,3)
ax3.set_title('Zoom (3 mm)')
ax3.pcolormesh(x*1e3,x*1e3,Itotal.T,cmap = 'gray',vmin=0,vmax=4)
buf3 = io.BytesIO()
plt.savefig(buf3, format='png')
buf3.seek(0)
clear_output()
figwidg3.value ="""<img src='data:image/png;base64,{}'/>""".format(base64.b64encode(buf3.getvalue()).decode('ascii'))
clear_output()
plt.close(fig3)
return
Positionwidg = widgets.FloatSlider(value=0.5,min=0.02,max=1.0,step=0.1,description='Dist fuente-biprism',orientation='horizontal')
changepos = widgets.interactive(changeBiprism,x0=Positionwidg)
resultswidg = widgets.HBox([figbox,Interfwidg])
display(changepos,resultswidg)
In [0]:
# Escribe el valor de la interfranja obtenido despues del signo igual a continuacion
Interfranja =
Para medir la separacion entre las dos fuentes virtuales creadas por el biprisma, no podemos hacerlo directamente en el laboratorio. Sin embargo, si colocamos una lente convergente despues del biprisma, esta formara una imagen real de esas fuentes virtuales, la cual si podemos medir en el laboratorio. La figura siguiente muestra el montaje que se llevara a cabo en el laboratorio.
En la siguiente simulacion, se plantea esta situacion. La figura a la izquierda reproduce el montaje experimental, pudiendo utilizar el desplazador para mover la posicion de la lente. La figura de la derecha muestra lo que se veria en la pantalla. Cuando la lente se encuentre en su posicion correcta, se formara en ella la imagen de las dos fuentes virtuales generadas por el biprisma. En la simulacion, apareceran los dos puntos mas definidos y mas pequeños. Finalmente, tambien se muestra el valor de la separacion entre esas imagenes virtuales $a'$.
Se propone por tanto mover la lente hasta que las imagenes se vean lo mas nitidas posibles, lo que nos permitira obtener los parametros que nos faltan para calcular la longitud de onda $\lambda$.
In [29]:
from matplotlib.patches import Circle
#Focal de la lente
fp = 0.2
# Separacion entre fuentes virtuales
x0 = Positionwidg.value
a = 2*x0*np.tan((n-1)*alpha) #separacion entre fuentes virtuales
xlimit = (D-x0)*np.tan((n-1)*alpha) # distancia desde el eje que ocupa el patron de interferencias
fig,ax = plt.subplots(1,1)
ax.plot(0,0,'o',lw=2)
ax.set_xlim(-0.1,D+0.1)
ax.set_ylim(-yrepres*1.5,yrepres*1.5)
ax.set_xlabel("x (m)")
ax.set_ylabel("y (mm)")
ax.set_title('Esquema del montaje experimental')
line1, = ax.plot(np.linspace(-1,D,50),np.zeros(50),'k')
buf = io.BytesIO()
plt.savefig(buf, format='png')
buf.seek(0)
figwidg = widgets.HTML("""<img src='data:image/png;base64,{}'/>""".format(base64.b64encode(buf.getvalue()).decode('ascii')))
plt.close(fig)
fig2,ax2 = plt.subplots(1,1)
ax2.set_xlabel("x (mm)")
ax2.set_ylabel("y (mm)")
#ax2.set_xlim(0,x.max()*1e3)
#ax2.set_ylim(-yrepres,yrepres)
ax2.set_title('Pantalla')
ax2.pcolormesh(np.zeros((500,500)))
buf2 = io.BytesIO()
plt.savefig(buf2, format='png')
buf2.seek(0)
figwidg2 = widgets.HTML("""<img src='data:image/png;base64,{}'/>""".format(base64.b64encode(buf2.getvalue()).decode('ascii')))
figboxlens = widgets.HBox([figwidg,figwidg2])
plt.close(fig2)
clear_output()
#########
aprimawidg = widgets.FloatText(0,description='a\'. (mm)',color='#C13535')
def changelens(xlens=D-0.1):
s = -xlens
sp = D - xlens
beta = sp/s
aprima = beta*a
figwidg.observe(repsetuplens(xlens),names='new')
spref = (D + np.sqrt(D**2 - 4*fp*D))/2 #Posicion correcta
sref = spref-D
figwidg2.observe(repimage(xlens,sref,aprima),names='new')
aprimawidg.observe(updateaprima(aprima),names='new')
return
def updateaprima(aprima):
aprimawidg.value=round(-aprima*1e3,2) # en mm
return
def repsetuplens(xlens):
fig,ax = plt.subplots(1,1,figsize=(7,5))
ax.plot(0,0,'o',lw=2)
ax.set_xlim(-0.1,D+0.1)
ax.set_ylim(-yrepres*1.5,yrepres*1.5)
ax.set_xlabel("x (m)")
ax.set_ylabel("y (mm)")
ax.set_title('Esquema del montaje experimental')
ax.plot(np.linspace(-1,D,50),np.zeros(50),'k')
ax.vlines(x0,-y0,y0,'r',lw=2)
ax.vlines(D,-y0*3,y0*3,lw=4)
ax.plot(np.linspace(x0,x0+.02,D),(-y0/.02)*np.linspace(x0,x0+.02,D) + y0*(1+x0/.02),'r',lw=2)
ax.plot(np.linspace(x0,x0+.02,D),(y0/.02)*np.linspace(x0,x0+.02,D) - y0*(1+x0/.02),'r',lw=2)
ax.annotate("", xy=(np.abs(xlens), y0*1.5), xytext=(np.abs(xlens),-y0*1.5),
arrowprops=dict(arrowstyle="<->",color='k')) # representacion lente
buf = io.BytesIO()
plt.savefig(buf, format='png')
buf.seek(0)
clear_output()
figwidg.value ="""<img src='data:image/png;base64,{}'/>""".format(base64.b64encode(buf.getvalue()).decode('ascii'))
clear_output()
plt.close(fig)
return
def repimage(xlens,sref,ap):
fig2,ax2 = plt.subplots(1,1,figsize=(4,4))
rad = 3*(xlens+ sref)**2 + 0.6 # Nota: sref < 0
circle1 = Circle((0,-ap*1e3/2), radius=rad, color='r',alpha = 1 - np.abs(xlens+sref))
circle2 = Circle((0,ap*1e3/2), radius=rad, color='r',alpha = 1- np.abs(xlens+sref))
ax2.add_artist(circle1)
ax2.add_artist(circle2)
ax2.set_ylabel("y (mm)")
ax2.set_xlim(-yrepres,yrepres)
ax2.set_ylim(-yrepres,yrepres)
ax2.set_title('Pantalla')
buf2 = io.BytesIO()
plt.savefig(buf2, format='png')
buf2.seek(0)
clear_output()
figwidg2.value ="""<img src='data:image/png;base64,{}'/>""".format(base64.b64encode(buf2.getvalue()).decode('ascii'))
clear_output()
plt.close(fig2)
return
PosLenswidg = widgets.FloatSlider(value=1,min=x0+0.05,max=1.0,step=0.03,description='Dist Fuente-Lente',orientation='horizontal')
changeposlens = widgets.interactive(changelens,xlens=PosLenswidg)
finalwidg = widgets.HBox([figboxlens,aprimawidg])
display(changeposlens,finalwidg)
In [0]:
a_prima =
In [0]:
aumento =
a =
In [0]:
long_de_onda =