4.1 Movimiento circular – Una partícula, animación

Simulando movimiento circular con Python

Se usa el concepto de fotograma, una «foto» por unidad de tiempo, como en el cine.

# 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

# Inicializa parametros de graficas (fotograma)
fotos=100
figura, cuadro = plt.subplots()
plt.axis('equal')
plt.axis([-1.5, 1.5, -1.5, 1.5])

# Valores iniciales de la grafica (1er fotograma)
angulo=0
x = np.cos(angulo)        # x-escalar
y = np.sin(angulo)        # y-escalar

punto, = cuadro.plot(x, y,'ro')

# Empieza la Animación
# Nuevas gráficas (n frame)
def redibuja(t):
    # determina los puntos x,y para cada t
    angulo=(2*np.pi/fotos)*t
    x=np.cos(angulo)
    y=np.sin(angulo)
    
    punto.set_xdata(x) # actualiza el punto
    punto.set_ydata(y)  
    return punto,

# Requerido para limpiar gráfica
def borrapizarra():
    punto.set_ydata(np.ma.array(x, mask=True))
    return punto,

# Genera nuevas gráficas
t = np.arange(1, fotos)
ani = animation.FuncAnimation(figura, redibuja, t ,
                              init_func=borrapizarra,
                              interval=10, blit=True)

narchivo = 'movimientocircular01' # nombre archivo
# Graba Archivo GIFAnimado y video
ani.save(narchivo+'_GIFanimado.gif',writer='imagemagick')

plt.show()

 

4.2 Movimiento circular – gráficas y animación

movimiento circular
vectores, graficas, animaciones
Movimiento circular, añadiendo línea de trayectoria y vector velocidad con Python.

Se añaden otros componentes a la gráfica del ejercicio anterior.

Instrucciones en Python

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

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

# inicializa parametros de fotos
fotos=100
figura, cuadro = plt.subplots()
plt.axis('equal')
plt.axis([-2, 2, -2, 2])

# Valores iniciales de la grafica (1er frame)
# posicion del punto
angulo=0
x = np.cos(angulo)      # x-escalar
y = np.sin(angulo)      # y-escalar
# velocidades en el punto
vx= -np.sin(angulo)
vy= np.cos(angulo)

# dibuja el punto y velocidades
punto, = cuadro.plot(x,y,'ro')
velocidad, = cuadro.plot([x,x+vx],[y,y+vy],'*-')
velx, =cuadro.plot([x,x+vx],[y,y],'*-.')
vely, =cuadro.plot([x,x],[y,y+vy],'*-.')
# Dibuja trayectoria circular
alfa= np.linspace(0,2*np.pi,fotos)
xt= np.cos(alfa)
yt= np.sin(alfa)
trayecto = cuadro.plot(xt,yt)

# Empieza la Animación
# Nuevas gráficas
def redibuja(t):
    # determina los puntos x,y para cada t
    angulo=(2*np.pi/fotos)*t
    x=np.cos(angulo)
    y=np.sin(angulo)
    # velocidad del punto
    vx= -np.sin(angulo)
    vy= np.cos(angulo)
    
    # actualiza gráficas
    punto.set_xdata(x) # actualiza el punto
    punto.set_ydata(y)
    velocidad.set_xdata([x,x+vx])
    velocidad.set_ydata([y,y+vy])
    velx.set_xdata([x,x+vx])
    velx.set_ydata([y,y])
    vely.set_xdata([x,x])
    vely.set_ydata([y,y+vy])
    return punto, velocidad, velx, vely,

# Init se requiere para limpiar la pizarra
def borrapizarra():
    punto.set_ydata(np.ma.array(x, mask=True))
    velocidad.set_ydata(np.ma.array(x, mask=True))
    velx.set_ydata(np.ma.array(x, mask=True))
    vely.set_ydata(np.ma.array(x, mask=True))
    return punto, velocidad, velx, vely,

# contador de fotos
t = np.arange(1, fotos)
ani = animation.FuncAnimation(figura, redibuja, t ,
                              init_func=borrapizarra,
                              interval=10, blit=True)

narchivo = 'movimientocircular02' # nombre archivo
# Graba Archivo GIFAnimado y video
ani.save(narchivo+'_GIFanimado.gif',writer='imagemagick')
plt.show()

 

3.1 Equilibrio Fuerzas – Grafica Vectores

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

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

Referencia: Sears –Zemanski , Física Universitaria. Vol 1. Edición 12.  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.

movpoyectil_01a

2.5 Cinemática – Gráficas tiempo vs distancia

Referencia: Sears-Zemansky Capítulo 2, Edición 12.
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


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 Capítulo 2, Edición 12.
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 y arreglos 1D, velocidad por tramos

Referencia: Sears-Zemansky Capítulo 2, Edición 12.
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 Programa 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

Referencia: Sears-Zemansky Capítulo 2, Edición 12.
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)

2.1 Cinematica – Algoritmo, Movimiento en Línea recta

Referencia: Sears-Zemansky Capítulo 2, Edición 12.
Diapositivas. Movimiento en linea recta.

Para plantear el movimiento en línea recta se consideran el punto de partida, llegada y tiempo de recorrido. En Python son variables que pueden obtener diferente valor para cada prueba.

Puede usar Python como calculadora y como programa.

1. Python como calculadora

Se   realizan los cálculos línea por línea

>>> tf=10
>>> d=194
>>> v=d/tf
>>> v
19.4
>>> vkmh=(v/1000)*60*60
>>> vkmh
69.83999999999999
>>> 

2. Python como Programa o Algoritmo

Diagrama de Flujo Básico
Diagrama de Flujo Básico

Para que el computador realice los trabajos de cálculo, se deben describir las instrucciones de forma ordenada, simple y muy clara. (Algoritmo)

Una forma de describir un Algoritmo es mediante gráficas conocidas como “Diagramas de Flujo”.

El “Programa” consiste en escribir las instrucciones del algoritmo en un lenguaje para computadora

Generalmente las instrucciones se escriben en inglés, siguiendo un formato (sintaxis) establecido por el lenguaje de programación.  Estructuras de Control en programación

Para éste curso, el lenguaje utilizado será Python

En las líneas de inicio, se comienza describiendo la razón por la que escribimos el “algoritmo” escrito en forma de “programa”

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

En el bloque de INGRESO, se Seleccionan datos conocidos al inicio,se determinan los tipos de datos, sean Variables simples: enteros o reales.
En el algoritmo o programa no se usarán inicialmente las unidades, se supondrá que son predeterminadas

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

En el bloque de procedimiento, para calcular la velocidad en el tramo se escribe la formula, incluso se puede cambiar de mts/seg a Km/h

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

En los bloques de salida y Fin, Se muestran los resultados encontrados y como fin del algoritmo en python de establece cuando no se encuentran líneas de instrucción

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

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)

1. Física Básica – Simulación con Python

En el caso de estar tomando el curso de Física-Cinemática, los siguientes temas te serán de ayuda como introducción a Python. Los temas de programación se desarrollan usando los ejemplos del libro Sears-Zemansky Capítulo 2, Edición 12.

1. Introducción

Paradigmas de Estudio de Ciencias

El concepto se amplía con el uso de simulaciones en computadora

Otro enfoque:

 

«Computers are incredibly fast, accurate, and stupid;
humans are incredibly slow, inaccurate, and brilliant;
together they are powerful beyond imagination». Albert Einstein