5.2 Optica – Rayo reflejado en plano inclinado con Python

Propagación multitrayecto o multicamino en plano inclinado

Referencia: Sears-Zemansky Cap33.2 Vol2 Ed.12 p1123, Optica – Rayo reflejado en plano horizontal

El plano de reflexión puede estar inclinado respecto al eje de las x. Para el caso dado, se puede considerar igualar las pendientes del rayo incidente y reflejado referenciadas con la pendiente del plano inclinado.

rayo reflejado en plano inclinado

la pendiente del plano inclinado se obtiene como:

m_s = \frac{\Delta suelo } {\Delta x_{intervalo}} = \frac{s_b-s_a}{x_b-x_a}

Respecto al plano, los ángulos de rayo incidente y reflejado son iguales por lo que secorrige con la pendiente del plano. Las pendientes del rayo izquierdo y rayo derecho con la influencia de la pendiente del suelo se igualan:

-(m_z-m_s) = m_r-m_s -m_z = m_r - 2 m_s

Para obtener sc como un punto en el plano, requiere función de suelo(x) evaluada en sc , para usar todo en función de xc :

m_s = \frac{\Delta s}{\Delta x} = \frac{s_b-s_a}{x_b-x_a} s(x) = m_s x_a +b_s b_s = s_a-m_s x_a s_c = s(c) = m_s x_c +b_s

Lo anterior permite actualizar el planteamiento de la pendientes, y despejar el valor de la incógnita xc

-m_z = m_r - 2 m_s - \frac{s_c-y_a}{x_c-x_a} = \frac{y_b-s_c}{x_b-x_c}-2m_s - \frac{s_c-y_a}{x_c-x_a} = \frac{y_b-s_c-2m_s(x_b-x_c)}{x_b-x_c}

primero se busca agrupar sc

-(x_b-x_c)(s_c-y_a) = (x_c-x_a)(y_b-s_c-2m_s(x_b-x_c))
-s_c(x_b-x_c)+y_a(x_b-x_c) = y_b(x_c-x_a)-s_c(x_c-x_a)-2m_s(x_b-x_c)(x_c-x_a)
-s_c(x_b-x_c) + s_c(x_c-x_a) = -y_a(x_b-x_c) + y_b(x_c-x_a) - 2m_s(x_b-x_c)(x_c-x_a)
s_c(-x_b+x_c+x_c-x_a) = -x_b y_a+x_c y_a + y_b x_c - x_a y_b -2m_s(x_b(x_c-x_a)-x_c(x_c-x_a))

sutituyendo sc con la expresión del plano con pendiente evaluada en el punto xc , lo que se expresa como:

(m_s x_c +b_s)(2 x_c-(x_a+x_b)) = x_c (y_a + y_b)-(x_a y_b -x_b y_a)-2m_s(x_b x_c- x_a x_b - x_c^2 + x_a x_c))

teniendo ahora como objetivo encontrar una expresión para xc

m_s x_c (2 x_c-(x_a+x_b))+b_s(2 x_c-(x_a+x_b)) = x_c (y_a + y_b)-(x_a y_b +x_b y_a)-2m_s(- x_c^2 + x_c(x_b + x_a) - x_a x_b)
2m_s x_c^2 - m_s x_c(x_a+x_b)+2 b_s x_c-b_s(x_a+x_b) = x_c (y_a + y_b)-(x_a y_b +x_b y_a)+ 2m_s x_c^2 - 2m_s x_c (x_b + x_a) + 2m_s x_a x_b
x_c(- m_s (x_a+x_b)+2 b_s)-b_s(x_a+x_b) = x_c (y_a + y_b- 2m_s (x_b + x_a))-(x_a y_b +x_b y_a) + 2m_s x_a x_b
x_c(- m_s (x_a+x_b)+2 b_s) -x_c (y_a + y_b- 2m_s (x_b + x_a)) = b_s(x_a+x_b) -(x_a y_b +x_b y_a) + 2m_s x_a x_b
x_c(2 b_s - (y_a + y_b) - m_s (x_a+x_b) + 2m_s (x_b + x_a)) = b_s(x_a+x_b) -(x_a y_b +x_b y_a) + 2m_s x_a x_b
x_c(2 b_s - (y_a + y_b) + m_s(x_a+x_b) = b_s(x_a+x_b) -(x_a y_b +x_b y_a) + 2m_s x_a x_b
x_c(2 b_s - (y_a + y_b) + m_s (x_a+x_b)) = b_s(x_a+x_b) -(x_a y_b +x_b y_a) + 2m_s x_a x_b
x_c = \frac{b_s(x_a+x_b) -(x_a y_b +x_b y_a) + 2m_s x_a x_b}{2 b_s - (y_a + y_b) + m_s (x_a+x_b)}

Con el valor de xc se pudede obtener la altura del punto sc. a partir de la ecuación que describe el plano s(x).

Algoritmo en Python

A partir del algoritmo del rayo reflejado en plano horizontal , se añaden las instrucciones para calcular ms, bs, xc, sc.

obteniendo ahora el resultado:

punto reflejado: [ 7.666666666666665 , 1.3333333333333335 ]

con la gráfica

rayo reflejado en plano inclinado grafica

Instrucciones en Python

# rayo incidente y reflejado
# en plano inclinado
# blog.espol.edu.ec/ccpg1001
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
# posición de antenas
xa = 1  # Izquierda
ya = 4
xb = 11 # Derecha
yb = 2

# plano el suelo
sa = 2
sb = 1

# muestras en grafica
muestras = 21

# PROCEDIMIENTO
# pendiente de suelo
ms = (sb-sa)/(xb-xa)
bs = sa-ms*xa
# punto de reflejo
numerador   = bs*(xa+xb)-(xa*yb+xb*ya)+2*ms*xa*xb
denominador = 2*bs-(ya+yb)+ms*(xa+xb)
xc = numerador/denominador

sc = ms*xc+bs

# SALIDA
print('punto reflejado: [',xc,',',sc,']')

# GRAFICA
#puntos en el plano
plt.scatter([xa,xc,xb],[ya,sc,yb])
plt.scatter([xc],[sc],label='punto reflejo')
# lineas de rayos
plt.plot([xa,xc],[ya,sc],label='incidende')
plt.plot([xc,xb],[sc,yb],label='reflejado')
plt.plot([xa,xb],[sa,sb],label='suelo')

# etiquetas anotadas
plt.annotate(' reflejo',[xc,sc])

# etiquetas
plt.legend()
plt.xlabel('x')
plt.ylabel('y')
plt.title('reflexión de rayos en plano inclinado')
plt.grid()

plt.show()

Tarea: Consiere que el suelo está compuesto de al menos dos segmentos con inclinaciones diferentes. Podría darse mas de una reflexión al punto de recepción o ninguna

Una aplicación relacionada de análisis multitrayecto en Girni: Coordenadas – Rayo reflejado en perfil por tramos

5.1 Optica – Rayo reflejado en plano horizontal con Python

Referencia: Sears-Zemansky Cap33.2 Vol2 Ed.12 p1123

El modelo de luz basado en rayos permite describir la propagación por: reflexión y refracción.

Un rayo de onda luminosa que incide en una material liso que separa dos materiales transparentes (como el aire y el vidrio o el agua y el vidrio), el rayo es reflejado parcialmente y también refractado parcialmente hacia el segundo material.

Los rayos incidente, reflejado y refractado en una interfaz lisa entre dos materiales ópticos forman ángulos θarb respecto a la normal (perpendicular) a la superficie en el punto de incidencia se ilustra en la figura. Si la superficie es rugosa, tanto la luz transmitida como la reflejada se dispersan en varias direcciones y no hay un ángulo único de transmisión o reflexión.

La reflexión con un ángulo definido desde una superficie muy lisa se llama reflexión especular ( latin de “espejo”). La reflexión dispersa a partir de una superficie áspera se llama reflexión difusa.

Propagación multitrayecto o multicamino en plano horizontal

Referencia: Propagación multicamino

En telecomunicaciones, la propagación de ondas de radio presentan un comportamiento semejante al de la luz para reflexión conocido como propagación multicamino o multitrayecto.

El fenómeno se da cuando las señales de radio llegan a la antena receptora por dos o más caminos y en diferentes tiempos.

La propagación mutitrayecto puede causar problemas en la recepción de la señal, debido a la interacción entre las señales recibidas. A fines prácticos, la señal obtenida en recepción difiere de la original y causa efectos que se han de compensar.

Ejercicio con gráfica

Realizar la gráfica de los rayos incidente, reflejado y directo entre el transmisor y receptor con antenas a diferentes alturas, semejante a la gráfica anterior.

Desarrollo

Si los ángulos incidente y reflejado son iguales, la pendiente rayo incidente debe ser igual en magnitud a la pendiente del rayo reflejado. Las pendientes tienen signo opuesto, el rayo izquierdo tiene pendiente negativa.

- \frac{\Delta y_{izquierda}} {\Delta x_{izquierda}} = \frac{\Delta y_{derecha}}{\Delta x_{derecha}} - \frac{s_c-y_a}{x_c-x_a} = \frac{y_b-s_c}{x_b-x_c}

Por facilidad de la ecuación, se supondrá que el suelo es paralelo al eje x, a una altura sc del eje de referencia.

Se debe obtener el valor de xc  de la ecuación anterior, que realizando un poco de trabajo se obtiene que:

- (x_b-x_c)(s_c-y_a) = (x_c-x_a)(y_b-s_c) - x_b(s_c-y_a) + x_c (s_c-y_a) = x_c (y_b-s_c)-x_a (y_b-s_c) x_c (s_c-y_a) - x_c (y_b-s_c)= -x_a (y_b-s_c) + x_b(s_c-y_a) x_c (2s_c-y_a-y_b)= -x_a (y_b-s_c) + x_b(s_c-y_a) x_c = \frac{x_b(s_c-y_a)-x_a(y_b-s_c)}{2s_c-y_a-y_b}

Obtenido el punto xc  y dado que el plano es horizontal, la altura  sc  es constante.

Con el algoritmo se puede obtener el punto de reflexión para varias alturas de antena y varias alturas del plano.

resultado con datos muestra:

punto reflejado: [ 8.5 , 1 ]

Instrucciones en Python

# rayo incidente y reflejado
# blog.espol.edu.ec/ccpg1001
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
# posición de antenas
xa = 1  # Izquierda
ya = 4
xb = 11 # Derecha
yb = 2

# plano el suelo
sc = 1  # altura

# muestras en grafica
muestras = 21

# PROCEDIMIENTO
numerador   = xb*(sc-ya)-xa*(yb-sc)
denominador = 2*sc-ya-yb
xc = numerador/denominador

# SALIDA
print('punto reflejado: [',xc,',',sc,']')

# GRAFICA
#puntos en el plano
plt.scatter([xa,xc,xb],[ya,sc,yb])
plt.scatter([xc],[sc],label='punto reflejo')
# lineas de rayos
plt.plot([xa,xc],[ya,sc],label='incidende')
plt.plot([xc,xb],[sc,yb],label='reflejado')
plt.plot([xa,xb],[sc,sc],label='suelo')

# etiquetas anotadas
plt.annotate(' reflejo',[xc,sc])

# etiquetas
plt.legend()
plt.xlabel('x')
plt.ylabel('y')
plt.title('reflexión de rayos en plano')
plt.grid()

plt.show()

Tarea:

a) Añadir la trayectoria directa del rayo entre el transmisor y receptor

b) Considerar que el plano puede estar inclinado respecto al eje de las x,por lo que para igualar las pendientes del rayo incidente y reflejado se referencian con la pendiente del plano.

m_s = \frac{\Delta suelo } {\Delta x_{intervalo}} = \frac{s_b-s_a}{x_b-x_a} -(m_z-m_s) = m_r-m_s -m_z = m_r - 2 m_s

4.1 Movimiento circular – Una partícula, animación con matplotlib-Python

Simular el movimiento circular de una partícula en el plano x,y considerando la variable tiempo consiste en definir las ecuaciones a usar para cada eje.

movimiento circular 01 GIFanimado

x(t) = \cos \Big( \frac{2 \pi}{T}t \Big) y(t) = \sin \Big( \frac{2 \pi}{T}t \Big)

donde T es el periodo de la función.

Para la gráfica se crean todas las muestras de los puntos en los tiempos ti que al graficarse mostraría un punto en cada posición ti. La animación consiste en usar el concepto de fotograma, una «foto» por unidad de tiempo como en el cine, es decir solo dibujar un punto a la vez, por cada foto ‘i’.

Los fotogramas dentro de un periodo se definen como fotos=20, y el retardo dt en milisegundos dentro del periodo es t/fotos*1000.

La animación requiere usar los procedimientos redibuja(i) y borrapizarra() para cada fotograma ‘i’. Los procedimientos usados o coordinados con la instrucción animation.FuncAnimation()

En caso de requerir un archivo gif animado se proporciona un nombre de archivo. Para crear el archivo se requiere de un complemento ‘imagemagick‘ a ser instalado.

# FCNM-ESPOL-2015. Fisica con Python
# Una particula en recorrido circular
# propuesta: edelros@espol.edu.ec

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# INGRESO
T = 4 # periodo en segundos
x_t = lambda t: np.cos(2*np.pi*t/T)
y_t = lambda t: np.sin(2*np.pi*t/T)

# intervalos ejes x,y 
x_a = -1.2 ; x_b =-x_a  # simétricos a 0
y_a = -1.2 ; y_b =-y_a

fotos  = 20   # muestras en un periodo
retardo = int(T/fotos*1000)  # milisegundos entre fotogramas

narchivo = 'movimientocircular01' # archivo.gif

# PROCEDIMIENTO
# Inicializa valores de muestras
i  = np.arange(0, fotos) # cuenta tramas
ti = np.linspace(0,T,fotos+1)
xi = x_t(ti)
yi = y_t(ti)

# SALIDA - Gráfica animada
figura, graf_xy = plt.subplots()
graf_xy.axis([x_a, x_b, y_a, y_b])
graf_xy.set_aspect('equal')
graf_xy.grid()
graf_xy.set_xlabel('x(t)')
graf_xy.set_ylabel('y(t)')
graf_xy.set_title('movimiento circular')
punto, = graf_xy.plot(xi[0], yi[0],'ro')

# cuadros de texto en gráfico
txt_x = (x_b+x_a)/2
txt_y = y_b*(1-0.09)
txt_ti = graf_xy.text(txt_x,txt_y,'t='+str(ti[0]),
                      horizontalalignment='center')

# Animación Nueva graf_xy (n frame)
def redibuja(i):
    # actualiza el punto
    punto.set_xdata(xi[i]) 
    punto.set_ydata(yi[i])
    # actualiza texto
    t_trama = np.around(ti[i],2)
    txt_ti.set_text('t= '+str(t_trama))
    return (punto,txt_ti)

def borrapizarra(): # limpiar gráfica
    punto.set_ydata(np.ma.array(xi, mask=True))
    txt_ti.set_text('')
    return (punto,txt_ti)

# Animación coordina
ani = animation.FuncAnimation(figura, redibuja, i ,
                              init_func=borrapizarra,
                              interval = retardo, blit=True)
# Graba Archivo GIFAnimado y video, requiere 'imagemagick'
#ani.save(narchivo+'_GIFanimado.gif',writer='imagemagick')

plt.show()

Otros ejercicios donde las animaciones son un complemento para mostrar resultados en otros cursos:

Gráfica animada para interpretar el Integral de convolución – Señales y Sistemas

Método de la Bisección – Concepto – Métodos Numéricos

Ecuaciones Diferenciales Parciales Parabólicas – Métodos Numéricos

4.2 Movimiento circular velocidad(t)- gráficas y animación con matplotlib-Python

Se añaden los componentes de velocidad por cada eje al algoritmo de movimiento circular de una partícula para obtener el resultado siguiente

movimiento circular velocidad 02 GIFanimado

v_x(t) = \frac{\delta}{\delta t} x(t) =-\frac{2\pi}{T}\sin \Big( \frac{2 \pi}{T}t \Big) v_y(t) = \frac{\delta}{\delta t}y(t) = \frac{2\pi}{T}\cos\Big( \frac{2 \pi}{T}t \Big)

donde T es el periodo de la función.

Los vectores de velocidad son líneas que parten desde la posición de la partícula y se extienden en magnitud de cada componente de la velocidad

vx, = graf_xy.plot([xi[0],xi[0]+vxi[0]],
                   [yi[0],yi[0]],'*-.')
vy, = graf_xy.plot([xi[0],xi[0]],
                   [yi[0],yi[0]+vyi[0]],'*-.')

en cada procedimiento redibuja(i) y borrapizarra() se incorpora el nuevo componente para actualizar las coordenadas y en la salida return().

Al incorporar los vectores de velocidad, se debe extender los intervalos de cada eje, con un exceso de 0.2 como espacio para mostrar el cuadro de texto para la variable tiempo.

Instrucciones en Python

# FCNM-ESPOL-2015. Fisica con Python
# velocidad de una particula en recorrido circular
# propuesta: edelros@espol.edu.ec

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# INGRESO
T = 4 # periodo en segundos
x_t = lambda t: np.cos(2*np.pi*t/T)
y_t = lambda t: np.sin(2*np.pi*t/T)
# velocidades
v_x = lambda t: -(2*np.pi/T)*np.sin(2*np.pi*t/T)
v_y = lambda t: (2*np.pi/T)*np.cos(2*np.pi*t/T)

# intervalos ejes x,y 
x_a = -1.8-.2 ; x_b =-x_a  # simétricos a 0
y_a = -1.8-.2 ; y_b =-y_a

fotos  = 40   # muestras en un periodo
retardo = int(T/fotos*1000)  # milisegundos entre fotogramas

narchivo = 'movimientocircular02' # archivo.gif

# PROCEDIMIENTO
# Inicializa valores de muestras
i  = np.arange(0, fotos) # cuenta tramas
ti = np.linspace(0,T,fotos+1)
xi = x_t(ti)
yi = y_t(ti)
vxi = v_x(ti)
vyi = v_y(ti)

# SALIDA - Gráfica animada
figura, graf_xy = plt.subplots()
graf_xy.axis([x_a, x_b, y_a, y_b])
graf_xy.set_aspect('equal')
graf_xy.grid()
graf_xy.set_xlabel('x(t)')
graf_xy.set_ylabel('y(t)')
graf_xy.set_title('movimiento circular')
punto, = graf_xy.plot(xi[0], yi[0],'ro')
# dibuja velocidad
velocidad, = graf_xy.plot([xi[0],xi[0]+vxi[0]],
                          [yi[0],yi[0]+vyi[0]],'*-')
vx, = graf_xy.plot([xi[0],xi[0]+vxi[0]],
                   [yi[0],yi[0]],'*-.')
vy, = graf_xy.plot([xi[0],xi[0]],
                   [yi[0],yi[0]+vyi[0]],'*-.')

# Dibuja trayectoria circular
trayecto = graf_xy.plot(xi,yi,linestyle='dotted')


# cuadros de texto en gráfico
txt_x = (x_b+x_a)/2
txt_y = y_b*(1-0.09)
txt_ti = graf_xy.text(txt_x,txt_y,'t='+str(ti[0]),
                      horizontalalignment='left')

# Animación Nueva graf_xy (n frame)
def redibuja(i):
    # actualiza el punto
    punto.set_xdata(xi[i]) 
    punto.set_ydata(yi[i])
    # actualiza velocidad
    velocidad.set_xdata([xi[i],xi[i]+vxi[i]])
    velocidad.set_ydata([yi[i],yi[i]+vyi[i]])
    vx.set_xdata([xi[i],xi[i]+vxi[i]])
    vx.set_ydata([yi[i],yi[i]])
    vy.set_xdata([xi[i],xi[i]])
    vy.set_ydata([yi[i],yi[i]+vyi[i]])
    
    # actualiza texto
    t_trama = np.around(ti[i],2)
    txt_ti.set_text('t= '+str(t_trama))
    return (punto,txt_ti,velocidad,vx,vy)

def borrapizarra(): # limpiar gráfica
    punto.set_ydata(np.ma.array(xi, mask=True))
    velocidad.set_ydata(np.ma.array(xi, mask=True))
    vx.set_ydata(np.ma.array(xi, mask=True))
    vy.set_ydata(np.ma.array(xi, mask=True))
    txt_ti.set_text('')
    return (punto,txt_ti,velocidad,vx,vy)

# Animación coordina
ani = animation.FuncAnimation(figura, redibuja, i ,
                              init_func=borrapizarra,
                              interval = retardo, blit=True)
# Graba Archivo GIFAnimado y video, requiere 'imagemagick'
ani.save(narchivo+'_GIFanimado.gif',writer='imagemagick')

plt.show()

 

3.1 Equilibrio Fuerzas – Grafica Vectores con Python

Fuerzas en equilibrio y Vectores , vectores, gráficas

Suma de vectores dadas las magnitudes y ángulos en grados sexagesimales, algoritmo usando Python.

Cuántos vectores:2
Componentes de los vectores:
magnitud[0]:1
angulo[0] (a°):50
magnitud[1]:2
angulo[1] (a°):160
magnitud: 1.905759540628703
ángulo: -49.543247280259386 grados

Para el ejercicio los vectores se expresan en magnitud y ángulo, los datos se ingresan en arreglos separados pero relacionados por el índice.

Para realizar las gráficas se cambian los vectores a coordenadas cartesianas, dado que la instrucción de gráfica de flechas requiere los puntos de partida y los puntos de llegada.

Instrucciones en Python

# FCNM-ESPOL-2015
# Graficar suma de vectores como trapecio
# Propuesta: Edison Del Rosario/
#            edelros@espol.edu.ec
import numpy as np
import matplotlib.pyplot as plt

# INGRESO de datos
n = int(input('Cuántos vectores:'))

print('Componentes de los vectores:')
A = np.zeros(n, dtype=float)
alfa = np.zeros(n, dtype=float)
i = 0
while (i<n):
    A[i]    = float(input('magnitud['+str(i)+']:'))
    alfa[i] = float(input('angulo['+str(i)+'] (a°):'))
    i = i+1

# PROCEDIMIENTO
# cambia coordenadas a cartesianas
Ax = np.zeros(n, dtype=float)
Ay = np.zeros(n, dtype=float)
i = 0
while (i<n):
    Ax[i] = A[i]*np.cos(alfa[i]*2*np.pi/360)
    Ay[i] = A[i]*np.sin(alfa[i]*2*np.pi/360)
    i = i+1
    
# Calcular Resultante
i  = 0
Sx = 0
Sy = 0
while (i<n):
    Sx = Sx + Ax[i]
    Sy = Sy + Ay[i]
    i = i+1
magnitud = np.linalg.norm([Sx,Sy])
grados = np.arctan(Sy/Sx)*(180/np.pi)

# Ubicar la posicion inicial de los vectores
px = np.zeros(n, dtype=float)
py = np.zeros(n, dtype=float)

# SALIDA de resultados
print('magnitud: '+str(magnitud))
print('ángulo: '+str(grados)+' grados')

# límites de los ejes
xmin = np.min([np.min(Ax),Sx,np.min(px)])
xmax = np.max([np.max(Ax),Sx,np.max(px)])
ymin = np.min([np.min(Ay),Sy,np.min(py)])
ymax = np.max([np.max(Ay),Sy,np.max(py)])
limite=np.array([xmin,xmax,
                 ymin,ymax])
plt.axis(limite)

# grafica de vectores
plt.quiver(px,py,Ax,Ay,
           color='blue', angles='xy',
           scale_units='xy', scale=1)
# grafica de vector suma
plt.quiver(0,0,Sx,Sy,
           color='green', angles='xy',
           scale_units='xy', scale=1,
           label = 'resultante')
plt.title('Suma de '+str(n)+' vectores')
plt.legend()
plt.show()

[Física Básica con Python]

2.6 Cinemática – Gráficas y subgráficas con Python

Referencia: Sears-Zemansky Vol1 Cap2.3 Vol1 Ed.12 p79. Ejemplo 3.16. Diapositivas. Movimiento de proyectiles

1. TALLER – Movimiento de proyectiles

La bola roja se deja caer desde el reposo y la amarilla se proyecta horizontalmente al mismo tiempo; las imágenes sucesivas en esta fotografía estroboscópica están separadas por intervalos de tiempo iguales.

En un instante dado, ambas bolas tienen la misma posición “y”, velocidad “y” y aceleración “y”, a pesar de tener diferente posición “x” y velocidad “x”.

Realizar la simulación usando Python, siguiendo las instrucciones dadas:

  • Determinar el intervalo de tiempo a usar
  • Determinar los valores iniciales de posición y velocidad para cada componente.
  • Inicializar y calcular la tabla de datos.
  • Suponer intervalos de medición unitarios
  • Calcular los valores de x(i), y(i) con las formulas conocidas.
    Presentar la gráfica de resultados

Resultado esperado:


2. Taller – Graficar las componentes

Se puede realizar una presentación tipo vista vertical, y vista horizontal, combinada usando

grafica, cuadro=plt.subplots(2,2)

Se dibujan los gráficos en cada cuadro, seleccionado por posición de fila y columna

cuadro[0,0].scatter(x2,y2,c='r',marker='o')
cuadro[0,1].scatter(x,y,c='y',marker='o')
cuadro[1,1].scatter(x3,y3,c='b',marker='o')
plt.show()

Puede añadir títulos y tramas a cada recuadro


3. Caida Libre

Una introducción a la física con Python, simular la caída de un objeto por varios segundos, graficando su posición en el espacio. La gráfica a mostrar es semejante a la del libro de Sears-Zemansky,

Lo más importante, es conocer del ejercicio en Física y seguir los pasos de forma ordenada. Es Física, simulando con programación..!

Instrucciones Python

# Primer programa de caída libre
# Una pelota se deja caer desde x0=1 m
# Desde una altura de 50 m
# Se observa en un tiempo [0,tn)
# edelros@espol.edu.ec

import numpy as np
import matplotlib.pyplot as plt

# INGRESO
tn = int(input('¿Cuantos segundos?:'))
# condiciones iniciales
t0 = 0
x0 = 1
y0 = 50

# PROCEDIMIENTO
# muestras del experimento
x=np.zeros(tn,dtype=float)
y=np.zeros(tn,dtype=float)
t=np.zeros(tn,dtype=float)

# aplica condiciones iniciales
t[0]= t0
x[0]= x0
y[0]= y0

# calcula los puntos siguientes
i=1
while (i<tn):
    t[i]=t[i-1]+1
    x[i]=x[0]
    y[i]=y[0]+0*t[i]+0.5*(-9.8)*(t[i]**2)
    i=i+1

# SALIDA - Gráfica
plt.scatter(x,y)
plt.ylabel('altura')
plt.xlabel('eje x')
plt.show()

Actividad Independiente:
a) Usando el archivo «caidalibreUnaPelota.py«, modificarlo para añadir una seguna pelota que inicia en la misma posición, pero con velocidad inicial en el eje de las x, v0x, la cual puede ser, positiva o negativa.

b) Generar las graficas de t vs y para ambos casos y comparar resultados.

movimiento de proyectil

2.5 Cinemática – Gráficas tiempo vs distancia con Python

Referencia: Sears-Zemansky Cap2.2 Vol1 Ed.12 p39
Diapositivas: Graficando tiempo vs distancia, velocidad y aceleración.

Situación propuesta: Observar en una gráfica los datos del ejercicio anterior.
Tomar lecturas de distancias y tiempos recorridos, para obtener velocidades por tramo en Kmh

Usaremos los resultados del ejercicio: velocidadtramos.py
Ejecutar el archivo con los datos del problema mostrado para obtener en memoria los resultados siguientes mostrados.

>>> d
array([   0.,  100.,  200.,  300.])
>>> t
array([ 0,  5,  9, 15])
>>> v
array([  0.      ,  20.      ,  25.      ,  16.66666667])
>>> vkmh
array([  0.,  72.,  90.,  60.])
>>>

1. Grafica desde linea de instrucciones

Se puede crear la gráfica paso a paso desde el Shell de
Python

Se requiere importar la librería para gráficas con el álias “plt” que es estandarizado.

>>> import matplotlib.pyplot as plt

Se crea la línea a graficar

>>> plt.plot(t,d)

Mostrar el gráfico construido

>> plt.show()

2. Añadir títulos de gráfico

>>> import matplotlib.pyplot as plt

Usar la forma interactiva para generar el gráfico, No se usa en el script

>>> plt.ion()
>>> plt.plot(t,d)
[<matplotlib.lines.Line2D object at 0x05A605F0>]
>>> plt.title('Distancia recorrida vs tiempo acumulado')
<matplotlib.text.Text object at 0x05A50630>
>>> plt.xlabel('tiempo segundos')
<matplotlib.text.Text object at 0x05A0A910>
>>> plt.ylabel('distancia en metros')
<matplotlib.text.Text object at 0x05A3C430>

Desconetar la interactiva con plt.ioff() y en el script:

>>> plt.show()


3. Colores y marcas de punto

Nos permiten realizar las gráficas de datos disponibles en un arreglo.
Se utiliza: plt.plot ( x, y, propiedades);
Las propiedades como el color y el punto se especifican entre apóstrofes:

Letra Color Símbolo forma
b Blue (azul) . Punto
g Green(verde) o círculo
r Red (rojo) x Marca de X
y Yellow (amarillo) + Marca de +
k Black (negro) s cuadro
w White(blanco v Triángulo
m magenta o pentagrama

las instrucciones a usar son:

>>> plt.plot(t,v,'ro-')
[]
>>> plt.title('velocidad observada vs tiempo acumulado')
>>> plt.xlabel('tiempo en segundos')
>>> plt.ylabel('velocidad en m/s')
>>> plt.show()

con lo que se obtiene


Taller – Aceleración media

Referencia: Física Universitaria Sears –Zemanski. Vol 1. Edición 12. Ejercicio 2.12

(2.12). Un piloto de pruebas de Automotores Galaxia, S.A., está probando un nuevo modelo de automóvil con un velocímetro calibrado para indicar m/s en lugar de mi/h. Se obtuvo la siguiente serie de lecturas  durante una prueba efectuada en una carretera recta y larga:

tiempo(s) 0 2 4 6 8 10 12 14 16
Rapidez(m/s) 0 0 2 6 10 16 19 22 22

a) Calcule la aceleración media en cada intervalo de 2 s.
¿La aceleración es constante? ¿Es constante durante alguna parte de la prueba?

b) Elabore una gráfica vx  –  t con los datos, usando escalas de 1 cm = 1 s horizontalmente, y 1 cm = 2 m/s verticalmente.
Dibuje una curva suave que pase por los puntos graficados.

Mida la pendiente de la curva para obtener la aceleración instantánea en: t =9 s, 13 s y 15 s.

Desarrollar el literal a) en Python

tiempo  = [0.0, 2, 4, 6,  8, 10, 12, 14, 16]rapidez = [0,   0, 2, 6, 10, 16, 19, 22, 22]

4. Subgráficos (subplots)

Permiten realizar grupos de gráficos en un esquema tipo matricial.
grafica, cuadro=plt.subplots(2)

El índice del primer cuadro es el cer0
cuadro[0].plot(x,y)

El siguiente cuadro es el uno
cuadro[1].step(tiempo,acelera,’r’)

Se pueden añadir o cambiar las propiedades de un cuadro:
cuadro[0].set_title(‘tiempo vs rapidez’)

Las instrucciones en Python desde la toma de datos son

# FCNM-ESPOL. Física con python
# calcular aceleracion media por intervalo
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
puntos  = int(input('¿puntos observados?:'))
tiempo  = np.zeros(puntos,dtype=int)
rapidez = np.zeros(puntos,dtype=float)
i = 0
while (i<puntos):
    tiempo[i]  = int(input('tiempo transcurrido (s):'))
    rapidez[i] = float(input('distancia recorrida (m/s):'))
    i = i + 1

# PROCEDIMIENTO
acelera = np.zeros(puntos,dtype=float)
i = 0
acelera[0] = 0
i = 1
while (i<puntos):
    acelera[i] = rapidez[i]-rapidez[i-1]
    i = i + 1

En el bloque de salida se puede añadir:

#grafica con dos cuadros
grafica,cuadro = plt.subplots(2)
cuadro[0].plot(tiempo,rapidez)
cuadro[0].set_title('tiempo vs rapidez')
cuadro[0].set_ylabel('rapidez (m/s)')
cuadro[1].step(tiempo,acelera,'r')
cuadro[1].set_title('tiempo vs aceleracion media')
cuadro[1].set_xlabel('tiempo (s)')
cuadro[1].set_ylabel('aceleracion (m/s2)')
plt.show()

2.4 Cinemática – Contadores, Acumuladores y arreglos

Referencia: Sears-Zemansky Cap2.2 Vol1 Ed.12 p39
Diapositivas: identificando cada punto observado.

Situación Propuesta

Identificar cada lectura de datos para el ejercicio de velocidad por tramos requiere un índice o número que sea único para cada lectura.

Se usa el concepto de contadores y acumuladores para llevar el control de los índices:

Contadores y Acumuladores en programación

Los arreglos permiten almacenar listas de datos, tal como las usadas en el ejemplo anterior:

>>d(1)
Ans = 100
>> t(3)
Ans=15

se observa que todas las variables tipo arreglo tienen:


Taller: Velocidad media

En el ejercicio mostrado, calcular la velocidad media como el promedio de los valores de velocidades.

 

2.3 Cinemática – lazos/bucles y arreglos 1D, velocidad por tramos con Python

Referencia: Sears-Zemansky Cap2.2 Vol1 Ed.12 p39
Diapositivas: Con varios puntos observados.

Situación propuesta

Tomar lecturas de distancias y tiempos recorridos, para obtener velocidades por tramo en Kmh

Lazos para Repetir

Usados cuando hay que repetir una operación o bloque de procedimiento. Se expresa como:

Estructura Mientras Repita
Mientras (condición): 
repita


while (condición):
    …

Lazos/Bucles – Estructuras para Repetir o iterar

Vectores – Arreglos de una dimensión

Usados cuando hay que almacenar una lista de datos, similar a la del problema propuesto.

Se requiere importar la librería numpy para facilitar el manejo de los datos. np es el alias de la librería

import numpy as np

Se inicializa el arreglo, llenándolo con ceros

d=np.zeros(puntos,dtype=float)
t=np.zeros(puntos,dtype=int)
i=0

Los arreglos inician en la fila 0, conocida como punto inicial.
Es necesario indicar los datos son enteros(int) o reales (float).

Vectores – Arreglos de una dimensión

resultado del algoritmo:

>>> 
¿puntos observados?:4
distancia recorrida (m):0
tiempo transcurrido (s):0
distancia recorrida (m):100
tiempo transcurrido (s):5
distancia recorrida (m):200
tiempo transcurrido (s):9
distancia recorrida (m):300
tiempo transcurrido (s):15
Velocidades en Kmh:
0.0
72.0
90.0
60.0

Algoritmo: Velocidad por tramos recorridos

# FCNM-ESPOL. Física con python
# varios tramos de recorrido
import numpy as np

puntos=int(input('¿puntos observados?:'))
d=np.zeros(puntos,dtype=float)
t=np.zeros(puntos,dtype=int)
i=0
while (i<puntos):
    d[i]=float(input('distancia recorrida (m):'))
    t[i]=int(input('tiempo transcurrido (s):'))
    i=i+1

#Procedimiento
v=np.zeros(puntos,dtype=float)
vkmh=np.zeros(puntos,dtype=float)
v[0]=0
vkmh[0]=0
i=1
while (i<puntos):
    v[i]=(d[i]-d[i-1])/(t[i]-t[i-1])
    vkmh[i]=(v[i]/1000)*60*60
    i=i+1

#Salida
print('Velocidades en Kmh:')
i=0
while (i<puntos):
    print(vkmh[i])
    i=i+1

Ejercicio para Taller

Velocidades por tramos, Implementar el algoritmo en python.

Lectura d t V V
metros seg m/s Kmh
0 0 0
1 100 5
2 200 9
3 300 15
4 400 19
5 500 25
6 600 33
7 700 38
8 700 45
9 800 55
10 800 15

2.2 Cinemática – Condicionales, Multas por exceso de velocidad con Python

Referencia: Sears-Zemansky Cap2.1 Vol1 Ed.12 p37
Diapositivas Multas por exceso de velocidad.

Situación propuesta: Determinar la velocidad del vehículo en Km/h y poner multas por exceso de velocidad sobre los 50Kmh.

Condicionales

Escrito en Python:

If (condición):
	VERDADERO
    else:
	FALSO

Los condicionales, permiten tomar decisiones o elegir las acciones como resultado de una operación lógica,

a>b         a=b
a<b         a>=b
a<=b       ; etc….

De la situación propuesta escrita en Python:

if (vkmh>50):
    sancion=1
else:
    sancion=0

Con lo que el algoritmo de velocidad media se convierte en:

Multa por velocidad limite

# FCNM-ESPOL. Fí­sica con python
# cálculo de multa por velocidad límite
# valores conocidos d y t
# sancion si exede los 50km/h
tf=int(input('¿cuantos segundos?: '))
d=float(input('¿distancia recorrida?: '))

v=d/tf
vkmh=(v/1000)*60*60
if (vkmh>50):
    sancion=1
else:
    sancion=0

print('Velocidad Media(Km/h)')
print(vkmh)
if (sancion==1):
    print('Tiene sancion por exceso de velocidad sobre 50 Km/h')

Ejercicio propuesto

Ampliar el uso del tema propuesto, solicitando la variable de velocidad “limite” para decidir si aplica una sanción

  • Zona escolar: 20 Km/h
  • Zona urbana: 50 Km/h
  • Via rápida urbana: 60 Km/h
  • Carretera: 90 Km/h

Velocidad Media

# FCNM-ESPOL. Física con python
# cálculo de velocidad
# valores conocidos d y t

tf = int(input('¿cuantos segundos?: '))
d  = float(input('¿distancia recorrida?: '))

v    = d/tf
vkmh = (v/1000)*60*60

print('Velocidad Media(Km/h)')
print(vkmh)