1 Geoscience: Applied Geophysics., Edu(1):1 VPYTHON Aplicaciones a la Física Educativa M.C. Omar Mireles August,2012 Abstract Se presenta en forma breve una descripción generalizada de las aplicaciones de la paqueteria visual python en la física computacional básica. Este trabajo se crea con la intención de que sea un manual de estudio. Los ejercicios comienzan a subir el nivel de di?cultad para el usuario, sin embargo al ?nal del manual se anexan los códigos completos, así como también se encuentran en la pagina www.geoscience.com.mx, en la sección de servicios/software/python. Muchos de los ejemplos aquí explicados tienen su origen en la red o en proyectos espe- cializados en el tema y propiedad de otros autores (la mayoria señalados en la bibliografía). Instalación Una reseña completa acerca de la instalación de visual python se puede encontrar en García (2008), así como algunos ejemplos de su uso en García (2008), Sanders (2010) y Marzal & Gracia (2003). En lo personal me funciono escribir en la terminal los siguientes códigos • sudo apt-get install python-visual • sudo apt-get install libgtkglextmm-x11-1.2-dev • sudo apt-get install python-cairo-dev 1
2 • sudo apt-get install python-gobject-dev • sudo apt-get install python-gtk2-dev • sudo apt-get install glade Para saber si esta bien instalado visual python (de ahora en adelante vpyt- hon), abre una terminal, escribe en ella python. Al hacer esto te mandara al ambiente python. Ahora escribe >?>?> from visual import sphere >?>?> s = sphere() Si al hacer esto se genera una esfera tridimensional, todo esta bien instalado (?gura 1). En caso contrario vuelve a intentarlo. Figura 1. Vista de los comandos desde el shell de python y la esfera que se genera al comprobar que visual pyhton este funcionando correctamente. El primer ejemplo: Grá?cador Para romper el hielo y demostrar que en general vpython es un lenguaje muy amigable construiremos un script que nos genere dos grá?cas en el mismo plano cartesiano y donde cada una de las líneas que gra?quemos este de diferente color. Como se menciono anteriormente, la primera línea que debemos de escribir (solo en ambiente Linux) es: #! /usr/bin/env python 2
Esta primera línea se escribe para poder redireccionar nuestro programa desde la Terminal hacia el interprete de Python. from visual import * from visual.graph import * En estas líneas estamos importando las paqueterias generales de vpython y una especializada en grá?cos. ecu1 = raw_input(’Escribir su ecuación usando lenguaje python: ’) ecu2 = raw_input(’Escriba segunda ecuación: ’) El comando raw- input lo utilizamos para que aparesca en pantalla el texto escrito entre comillas, y despues de que el usuario introduzca la peticion, esta se guarde en una variable asignada (en nuestro caso ecu1 y ecu2). Para saber más a fondo como escribir ecuaciones en python recomiendo el tutorial “Introducción a la Programación con Python” de Marzal. f1 = gcurve(color=color.cyan) f2 = gcurve(color=color.yellow) El comando gcurve tiene 4 elementos (x,y,radio,color). En este caso solo le estamos asignando un color a cada curva, los otros valores los designaremos con la siguiente orden: for x in range(0,20,0.1): f1.plot(pos=(x,eval(ecu1))) f2.plot(pos=(x,eval(ecu2))) Aquí, en el ciclo f or se de?nen (x, y, radio). f 1.plot genera la grá?ca de la curva f 1 y f 2.plot la de f 2. La salida del programa (./graf ica.py) es un entorno grá?co (?gura 2) que nos permite dos grá?cas conjuntas. 3
Figura 2. Salida del script anterior con la función sin(x) y cos(x). 3 Átomo Siguiendo la línea de aprendizaje, ahora crearemos una pequeña animación con más ?nes didácticos que físico-computacionales. La intención de este script es ilustrar la lógica de vpython para crear objetos y dotarlos de movimiento. Vamos a crear un átomo con un núcleo y un par de electrones girando alrededor de esté. Como siempre, en linux nuestra primera línea debe ser: #! /usr/bin/env python La segunda línea que debe de acompañar a un script en python es la que señala las paqueterias que se van a bajar para que corra el resto del código, que en nuestro caso sería: from visual import * Despues debemos de crear la escena donde se van a formar todas las ?guras: scene2 = display(title=’ATOMO: Helio’,x=0, y=0, width=600, height=500,center=(5,0,0), background=(0.6,0.3,1)) scene2.lights = [vector(10,0,0)] 4
De estas dos líneas podemos concluir que: • title crea el titulo en la ventana principal. • x y y, son la posición inicial de nuestra escena. • width y height, son el ancho y largo de la escena. • center marca la posición a partir de donde se van a crear las ?guras. • background crea el color de fondo de la ventana. La segunda línea afecta a scene2 y se trata de un vector el cuál le coloca sombra a los objetos que formaran al átomo. n1 = sphere(pos=(1,0,0), radius=1, color = color.green) n2= sphere(pos=(2,1,0), radius=1, color = color.green) p1 = sphere(pos=(2,0,0), radius=1, color = color.red) p2 = sphere(pos=(1,1,0), radius=1, color = color.red) Estas cuatro líneas crean cuatro esferas (2 verdes y 2 rojas), las cuales van a formar el núcleo de nuestro átomo. e1 = sphere(pos=(15,7,0), radius=0.5, color = color.blue) e2 = sphere(pos=(-3,15,5), radius=0.5, color = color.blue) Con estas líneas se forman los electrones en color azul. Hasta aquí ya tenemos terminada la escena general con la que vamos a trabajar, sin embargo todavia no le damos movimiento ni dinamicidad a nuestro trabajo. Para comenzar escribamos las siguientes tres líneas: dt=0.1 curva1= curve() curva2= curve() El dt es el paso diferencial que vamos a utilizar. Despues creamos dos ele- mentos abiertos (curva1 y curva2), eso signi?ca que existen pero los cuales no tienen de?nidos ningun valor. La intencion de esto ultimo es crear la ?gura pero adaptar su existencia a nuestra necesidad. Una vez mas este ultimo paso es mas por estetica que por cualquier otra cosa. El objetivo es que las orbitas de los electrones se vallan creando al avanzar estos. Por ultimo, vamos a dotar de movimiento a nuestros electrones: 5
4 while 1: rate(20) dt=0.1 e1.rotate(angle=-dt, origin=(0,0,0), axis=(-0.3,0.8,0.3)) e2.rotate(angle=-dt, origin=(0,0,0), axis=(1,0.4,0.6)) curva1.append(pos=e1.pos) curva2.append(pos=e2.pos) El movimiento aquí se crea con un ciclo while el cual corre desde 1 hasta rate, el cual se puede traducir en la velocidad con la que correran los electrones (entre rate sea mas chico el electron viajara mas lento). Despues le aplicamos una función llamada rotate a los electrones e1 y e2 y la salida de este movimiento lo asociamos a las curvas 1 y 2, las cuales se formaran al avanzar el electrón. El resultado ?nal (./atomo1.py) se puede observar en la ?gura 3. Figura 3: Imágen del átomo de Helio Este tipo de trabajos, más que una simulación numérica presentan una ani- mación sin mucho trasfondo matemático o físico. Pasemos ahora a algo un poco más complicado. Movimiento Parabólico Este ejemplo fue tomado casi en su totalidad del tutorial de Proyecto Physthones (García, 2008) y esta adicionado con unas pequeñas modi?caciones personales para hacerlo más completo y sacarle todo el jugo posible a este script. Antes de meternos a escribir el código recordemos un poco las leyes físicas alrededor del movimiento parabólico. 6
4.1 Movimiento de Proyectiles Un proyectil es cualquier cuerpo que recibe una velocidad inicial y luego si- gue una trayectoria determinada totalmente por los efectos de la aceleración gravitacional y la resistencia del aire. Para analizar este tipo de movimiento, partiremos de un modelo idealizado que representa al proyectil como una partícula con una aceleración (debida a la gravedad) constante en magnitud y dirección. Ignoraremos los efectos del aire y la curvatura y rotación de la Tierra. Figura 4. Diagrama vectorial del movimiento parabólico En la ?gura 4 se puede observar que el movimiento de un proyectil está limi- tado a un plano determinado por la dirección de la velocidad inicial. La razón es que la aceleración debida a la gravedad es puramente vertical; la gravedad no puede mover un proyectil lateralmente. Por tanto, este movimiento es bi- dimensional. Llamaremos al plano de movimiento “plano xy”, con x en el eje horizontal y el y vertical hacia arriba. El análisis del movimiento de proyectiles permite tratar a x y a y por separa- do. Otro elemento que va a facilitar nuestro trabajo es cuando nos damos cuenta que la componente x de la aceleración es 0, y la componente y es constante e igual a -g. Así podemos analizar el movimiento de un proyectil como una com- binación de un movimiento horizontal con velocidad constante y movimiento vertical con aceleración constante (Sears et al, 1999). Para el movimiento en x tenemos que: vx = v0x x = x0 + v0x t 7 (1) (2)
4.2 Para el movimiento en y tenemos que: vy = v0y – gt 1 y = y0 + v0y t – gt2 2 (3) (4) Para ver con más detalle como se obtuvieron estas expresiones puede con- sultar el libro de Física Universitaria, capitulo 3, sección 4. Generalmente, lo más sencillo es tomar la posición inicial (en t = 0) como origen; así, x0 = y0 = 0. La ?gura 4 muestra la trayectoria de un proyectil que parte de (o pasa por) el origen en t = 0. La posición, velocidad, componentes de la velocidad y la aceleración se muestran en una serie de instantes equies- paciados. La componente x de la aceleración es 0, así que vx es constante. La componente y es constante pero no 0, así que vy cambia en cantidades iguales a intervalos iguales. En el punto más alto, vy = 0 (Feynman et al, 1998). El Script: Movimiento de un Proyectil Iniciamos nuestro archivo como siempre: #! /usr/bin/env python from visual import * Después generamos la ventana donde se visualizarán los grá?cos llamándola scene y le daremos como atributos un tíitulo y le decimos que no queremos que haga autoscale. El autoscale lo que hace es mover el zoom de la cámara para que todos los objetos se vean. Suele resultar bastante incómodo y el botón central del ratón nos permitirá hacer eso manualmente sobre la marcha. scene = display() scene.title = ’Movimiento de un Proyectil’ scene.autoscale = 0 Ahora vamos a de?nir unos valores iniciales para el problema, que serán la posición y velocidad de la partícula en el instante inicial. pos = vector(-10,0,0) vel = vector(10,10,0) 8
El vector pos y vel estan de?nidos en un espacio tridimensional (aunque se- ñalamos anteriormente que el movimento parabólico de un proyectil se explica en un plano bidimensional) por motivos de que vamos a crear una escena tridi- mensional. Ahora viene el momento en que animamos la escena. Hemos puesto un paso dt muy pequeño, cuanto más pequeño más lenta (y más precisa) será la simulación, de modo que sólo cuando t ? 0 la solución coincidirá exactamen- te con la trayectoria analítica. Despues de?nimos la aceleración (componente x = 0 y y = -g) y la aceleración gravitacional (como 10) y el valor inicial cuando t = 0. grav = 10 acel = vector(0,-grav,0) dt=1./300. t=0 Ahora crearemos los acuatro elementos principales en nuestra escena (el piso, un cañon, una bala y la trayectoria de desplazamiento de la bala): proyectil = sphere(pos=pos,color=color.blue,radius=0.5) suelo = box(pos = (0,-1,0),size = (25,0.1,25),color = color.red) cannon = cylinder(pos = pos,axis = (1,1,0)) trayectoria = curve(color = color.white) Para hacer más grá?co este modelo coloquemos tres vectores que acompañen a la bala en su trayectoria; un vector verde que representa la componente de la velocidad en x, un vector cyan que representa la componente de la velocidad en y y un vector rojo que representa la magnitud total de la velocidad. velocidadtotal = arrow(color = color.red,pos = proyectil.pos,axis = vel/3.) velocidadx = arrow(color = color.green,pos = proyectil.pos,axis = (vel.x/3.,0,0)) velocidady = arrow(color = color.cyan,pos = proyectil.pos,axis = (0,vel.y/3.,0)) Aquí el comando arrow crea un vector que depende de tres elementos; a) color, b) posición (que en nuestro caso estamos usando la misma que la del proyectil) y c) eje (en nuestro caso estamos utilizando la misma que la inicial del vector vel). El núcleo de la animación es un bucle while que viene a decir que mientras la coordenada y del proyectil sea mayor o igual que 0 el sistema repita los pasos de dentro del bucle. Esos pasos consisten sencillamente en avanzar intervalos diferenciales y actualizar a cada paso los valores de la posición, velocidad y aceleración dados por el sistema de ecuaciones descrito anteriormente. 9
Según lo hemos escrito, en un ordenador lento el movimiento se producirá muy despacio y en un ordenador rápido se producirá deprisa. Para poder con- trolar el tiempo de manera realista debemos jugar con el número de fotogramas por segundo y el intervalo diferencial. Para eso se utiliza el comando rate. Si queremos, por ejemplo, 25 fotogramas por segundo (aproximadamente los que ofrece una pantalla de televisión) pondremos: rate(25). Finalmente esta parte del código queda como: while pos.y >= 0: vel = vel+acel*dt pos = pos+vel*dt trayectoria.append(pos) proyectil.pos = pos velocidadtotal.pos = pos velocidadx.pos = pos velocidady.pos = pos velocidadtotal.axis = vel/3. velocidadx.axis = vector(vel.x/3.,0,0) velocidady.axis = vector(0,vel.y/3.,0) t = t+dt rate(50) Aquí la velocidad y la posición fueron de?nidas en su forma diferencial (pa- ra más detalle ver Feynman et al, 1999). El resultado de este pequeño script (./proyectil.py) se puede observar en la ?gura 5. Figura 5. Resultado del script del Movimiento de un Proyectil. Se puede observar asociado a la bala del añon un vector rojo que representa la velocidad total, un vector verde que representa la velocidad en la componente x y un vector cyan que representa la velocidad en la componente y. 10
2 4.3 Energía vs Tiempo Ahora vamos a hacer unas modi?caciones al script para que al momento de correr la animación se genere una grá?ca donde se pueda visualizar la energía cinética, potencial y total como función del tiempo. Para hacer esto vamos a extraer parte del primer código que escribimos. Pero antes de seguir recordemos un poco las ecuaciones de la energía. Tenemos dos tipos de energía; una que esta asociada al movimiento de la partícula y otra asociada a su altura. La primera se denomina Energía Cinetica de un cuerpo y es aquella energía que posee debido a su movimiento. Se de?ne como el trabajo necesario para acelerar un cuerpo de una masa determinada desde el reposo hasta la velocidad indicada. Una vez conseguida esta energía durante la aceleración, el cuerpo mantiene su energía cinética salvo que cambie su velocidad. Para que el cuerpo regrese a su estado de reposo se requiere un trabajo negativo de la misma magnitud que su energía cinética. Su expresión matemática es 1 K = mv2 (5) La segunda se llama Energía Potencial y es energía que mide la capacidad que tiene dicho sistema para realizar un trabajo en función exclusivamente de su posición o con?guración. Puede pensarse como la energía almacenada en el sistema, o como una medida del trabajo que un sistema puede entregar. Su expresión matemática es U = mgh (6) Por ultimo la Energía Total es la suma de la energía cinetica y la energía potencial E = K + U (7) Los nuevos cambios se veran re?ejados en 9 nuevas líneas. Las primeras líneas se colocaran abajo de la línea 6, y estan dirigidas a cambiar el color de fondo de la escena (comando background), y crear las condiciones para la grá?ca: scene.background = (1,1,1) graph1 = gdisplay(x=0,y=0,width=600,height=450, ? title=’E vs t’, xtile=’t’, ytitle=’E’,foreground=color.black ? background=color.white) Las siguientes líneas tendran como objetivo crear las tres líneas que repre- senten la energía. 11
potencial = gcurve(gdisplay=graph1,color.blue) cinetica = gcurve(gdisplay=graph1,color.red) etotal = gcurve(gdisplay=graph1,color.green) Abajo de la línea 14 de?nimos en valor de la masa. m=1 Abajo de la línea 36 (dentro del ciclo while) de?nimos las ordenes para gra?car. cinetica.plot(pos=(t,0.5*m*mag2(vel))) potencial.plot(pos=(t,m*grav*proyectil.pos.y)) etotal.plot(pos=(t,m*grav*proyectil.pos.y + 0.5*m*mag2(vel))) El resultado de este cambio (./proyectil2.py) se puede ver en la ?gura 6. Figura 6. En la parte izquierda se muestra la gra?ca de E vs t. En la parte derecha de forma conjunta se muestra el movimiento de un proyectil. 12
5 Caida libre Es hora de comenzar a soltarnos un poco. Este script que vamos a construir tiene la intención de resolver el siguiente problema: “ Se sueltan dos bolas de masa m al mismo tiempo to = 0. Una bola se deja caer en forma vertical y la otra con un movimiento parabólico como se muestra en la ?gura 7. ¿Cuál llegara primero al suelo?” (para más detalle ver cap. 3, Movimiento en dos o tres dimensiones, Sears, 1999). Figura 7. Diagrama que muestra la trayectoria de dos cuerpos en caida libre Si ya quedo claro el problema comencemos a diseñar el código. Como siempre las dos primeras líneas son Redireccionamiento al interprete de python Importación de las paqueterias de trabajo Despues crearemos la escena donde trabajaremos display(title=’titulo’, width=ancho,height=alto,background=(color de fondo)) El titulo title es una palabra o frase escrita entre comas altas, el ancho y la altura se dan en pixeles (por ejemplo 550), el código de color es RGB y se puede escribir con números enteros, decimales o fracciones que se dividan con respecto a 255 (ejemplo 220.0/255, 255.0/255, 130.0/255). Ahora vamos a crear los elementos de nuestra escena (el piso y dos bolas de diferente color). Primero para el piso: 13
piso=box(pos(x,y,z),width,height,lenght,color,axis) Los atributos de la caja son; pos, sirve para posicionar la altura en que se creara el plano; width, height y length son lo ancho, alto y profundo de la caja; axis, marca la posición (inclinación) de la caja. Para las bolas: bola1=sphere(pos=(),radius=(),color) Aquí aparece otro atributo nuevo; el atributo radius crea la dimensión de la bola (también puede operar en líneas). Ee este tipo de lenguajes es muy común utilizar funciones prede?nidas. Este tipo de funciones se utilizan escribiendo el nombre de la función, un punto, y despúes su atributo. Como ejemplo, la función color ya esta de?nida, si deseamos invocar uno de los 8 colores básicos (negro, rojo, azul, blanco, amarillo, verde, cyan y magenta) escribimos color.blue. Ahora, para darle un poco de originalidad al script, le vamos a pedir que aparte de hacer la simulación numérica, nos arroje cuatro valores de salida en todo momento (altura, rapidez, tiempo y alcance). alcande = label(pos=(x,y,z),text=”) A partir de este momento estamos listos para comenzar a introducir las condiciones iniciales de nuestro sistema: Comencemos creando estos valores para la bola 1 (la que tiene velocidad inicial). b1vx = 15 b1vy = 0 Y creando dos nuevos grupos de valiables, las cuales me serviran para deter- minar las posciones iniciales y ?nales: b1x = bola1.pos.x b1y = bola1.pos.y pox1 = bola1.pos.x poy1 = bola1.pos.y Ya que en esta ocación tenemos de?nidos cuatro recuadros donde se tendrán los datos instantaneos de rapidez y tiempo, debemos de?nir un paso diferencial cuando el límite tiende a cero, esto es: dt = 0. 14
Como siempre, la forma más sencilla de dotar de movimiento nuestra simu- lación es con un ciclo while while 1: rate(numero de cuadros) dt +=0.005 if bola1.pos.y > 0.5: Para programar las ecuaciones debemos de recordar un poco el compor- tamiento de este sistema dual de proyectiles en caida libre. Analizando fotos estroboscopicas de este sistema (?gura 8), se sabe que en un instante dado, am- bas bolas tienen la misma posición y, velocidad y, y aceleración y, a pesar de tener diferente posición x y velocidad x (Sears, 1999). Figura 8. Posición de dos bolas en caida libre en diferentes tiempos. Sabiendo lo anterior comencemos a nalizar el sistema por separado: • Para la bola 1 Esta bola tiene una rapidez inicial en la componente x (igual a 15 m/s) y eny = 0. Analizando las ecuaciones (1-4) tenemos que Vx = Vox = 15 15
2 2 2 2 x = xo + Vox t Vy = Voy – gt = -gt 1 y = yo + Voy – gt2 = yo – 4.9t2 2 • Para la bola 2 Vx = 0 x = xo = 0 Vy = Voy – gt = -gt 1 y = yo + Voy t – gt2 = -4.9t2 2 Programando estas ecuaciones tendremos que: bola1.pos.y = yo – Voy t – 1 gt2 bola1.pos.x = xo – Vox t Como siempre, vamos a asociar una trayectoria a cada bola, y aprovechando vamos a generar una barra que marque la distancia de separación entre ambas bolas. curve(pos=[(xo , yo , zo ),(xf , yf , zf )],color=,radius=) Ya teniendo esto vamos a enlazar los valores de salida a sus respectivos recuadros. alcance.txt=’Alcance’ + str(round(x2-x1,2)) + ’m’ Para la rapidez conviene primero analizar que salida es la que queremos. En pasos anteriores hemos de?nido la componente de la velocidad en x y en y, sin embargo lo que nosotros queremos es la magnitud de la velocidad, en otras palabras lo que queremos es rapide = Como Vy = -gt nos queda rapide = Vox + Voy Vox + (9.8t)2 y para ?nalizar establecemos los parametros ?nales de cierre 16
b1x = bola1.pos.x b1y = bola1.pos.y El resultado de este programa al correr el codigo (./proyectil3.py) se muestra en la ?gura 9. Figura 9. Resultado del script del sistema de dos bolas en caida libre 6 Vectores Otro tema de importancia para la física es el de los vectores ya que con estos se pueden resolver los problemas del movimiento en dos y tres dimensiones. El primer ejemplo que trataremos aquí es de la suma de dos vectores utilizando el método del polígono. El método del polígono para sumar vectores dice que, el vector resultante se obtiene dibujando cada vector a escala, colocando el origen de un vector en la punta de la ?echa del otro hasta que todos los vectores queden representados. La resultante es la línea recta que se dibuja a partir del origen del primer vector hasta la punta del último (Tippens, 2001). 6.1 Vectores 2D Suponga que una partícula sufre un desplazamiento A seguido de un desplaza- miento B, el resultado ?nal es el mismo que si la partícula hubiera sufrido un solo desplazamiento C igual a la suma de la magnitud de A + B (Sears et al, 1999). 17
Como ejemplo, podemos suponer que tenemos un avión que realiza los mo- vimientos de la ?gura 10 (vistos desde la pantalla del controlador de vuelo) Figura 10. Las ?echas rojas marcan el trayecto de un avión Al analizar la pantalla con cuidado podemos concluir que • El avión partio de las coordenadas Ao (0, 0) y esa parte del trayecto la terminó en Af (3, 3) • El trayecto B lo inicio en Bo (3, 3) y lo terminó en Bf (6, 1) • El trayecto resultante es C = A + B = (3, 3) + (6, 1) = (9, 4) Comencemos con el código de este problema utilizando el método del polí- gono: Redirección al interprete de Python Importar paqueterias crear escena (con tamaño) ponerle titulo a la escena crear el rango de la escena construir los valores de inicio y ?n del vector 1 construir los valores de inicio y ?n del vector 2 construir los valores de inicio y ?n del vector resultante resolver la magnitud del vector 1 18
resolver la magnitud del vector 2 resolver la magnitud del vector resultante crear el eje x crear el eje y Dotar de movimiento el vector 1 Dotar de movimiento el vector 2 Dotar de movimiento al vector resultante Escribir como salida en la Terminal, la magnitud del vector resultante El resultado de este código se puede observar en la siguiente ?gura (./su- ma2vectores.py) Figura 11. Suma de dos vectores donde se muestra la resultante en rojo 6.2 Vectores 3D 19
Figura 12. Suma de tres vectores en un plano tridimensional La ?gura 12 muestra el resultado de un script que resuelve la suma de tres vectores por el método del polígono. Para hacer más divertido y útil este pro- grama vamos a construirlo a partir de una necesidad. Resuelve el siguiente problema de vectores y escribe su código (pero ahora que el resultado salga en la misma escena): “ Un barco recorre 100 km hacia el norte durante el primer día de viaje, 60 km al nordeste el segundo día, y 120 km hacia el este el tercer día (?gura 13). Encuentre el desplazamiento resultante con el método del polígono”. Figura 13. Trayectoria de recorrido del barco en 3 días. 20
7 Apéndice de códigos 7.1 Gra?cador #! /usr/bin/env python #************************************* from visual import * from visual.graph import * #introduciendo las funciones f(x) ecu1= raw_input("Escriba su ecuacion usando lenguaje python: ") ecu2= raw_input("Escriba su segunda ecuacion : ") #gcurve(x=x,y=0, radius=0.1, color=color.blue) f1=gcurve( color=color.cyan) f2=gcurve( color=color.yellow) for x in arange(0,20,0.1): f1.plot(pos=(x, eval(ecu1))) f2.plot(pos=(x, eval(ecu2))) #****************FIN************************** 7.2 Atomo de Helio #! /usr/bin/env python from visual import * scene2 = display(title=’ATOMO’,x=0, y=0, width=600, height=500,center=(5,0,0), background=(0.2,0.3,1)) scene2.lights = [vector(6,0,2)] n1 = sphere(pos=(1,0,0), radius=1, color = color.green) n2= sphere(pos=(2,1,0), radius=1, color = color.green) p1 = sphere(pos=(2,0,0), radius=1, color = color.red) p2 = sphere(pos=(1,1,0), radius=1, color = color.red) e1 = sphere(pos=(15,7,0), radius=0.5, color = color.blue) e2 = sphere(pos=(-3,15,5), radius=0.5, color = color.blue) dt=0.1 curva1= curve() curva2= curve() while 1: rate(20) dt=0.1 e1.rotate(angle=-dt, origin=(0,0,0), axis=(-0.3,0.8,0.3)) e2.rotate(angle=-dt, origin=(0,0,0), axis=(1,0.4,0.6)) 21
curva1.append(pos=e1.pos) curva2.append(pos=e2.pos) #**************************FIN**************************** 7.3 Proyectil 1 #! /usr/bin/env python from visual import * scene = display() scene.title = ’Movimiento de un Proyectil’ scene.autoscale = 0 pos = vector(-10,0,0) vel = vector(10,10,0) grav = 10 acel = vector(0,-grav,0) dt = 1./300. t=0 proyectil = sphere(pos=pos,color=color.blue,radius=0.5) suelo = box(pos = (0,-1,0),size = (25,0.1,25),color = color.red) cannon = cylinder(pos = pos,axis = (1,1,0)) trayectoria = curve(color = color.white) velocidadtotal = arrow(color = color.red,pos = proyectil.pos,axis = vel/3.) velocidadx = arrow(color = color.green,pos = proyectil.pos,axis = (vel.x/3.,0,0)) velocidady = arrow(color = color.cyan,pos = proyectil.pos,axis = (0,vel.y/3.,0)) while pos.y >= 0: vel = vel+acel*dt pos = pos+vel*dt trayectoria.append(pos) proyectil.pos = pos velocidadtotal.pos = pos velocidadx.pos = pos velocidady.pos = pos velocidadtotal.axis = vel/3. velocidadx.axis = vector(vel.x/3.,0,0) velocidady.axis = vector(0,vel.y/3.,0) t = t+dt rate(50) #****************FIN************************** 22
7.4 Proyectil 2 #! /usr/bin/env python from visual import * from visual.graph import * scene = display() scene.title = ’Movimiento de un Proyectil’ scene.autoscale = 0 # linea 1 nueva scene.background = (1,1,1) # linea 2 nueva graph1 = gdisplay(x=0, y=0, width=600, height = 450, title = ’E vs t’, xtitle = ’t’, ytitle = ’E’, foreground = color.black, background = color.white) # Linea 3 nueva potencial = gcurve(gdisplay = graph1, color = color.blue) cinetica = gcurve(gdisplay = graph1, color = color.red) etotal = gcurve(gdisplay = graph1, color = color.green) pos = vector(-10,0,0) vel = vector(10,10,0) grav = 10 # Linea 4 nueva m=1 acel = vector(0,-grav,0) dt = 1./300. t=0 proyectil = sphere(pos=pos,color=color.blue,radius=0.5) suelo = box(pos = (0,-1,0),size = (25,0.1,25),color = color.red) cannon = cylinder(pos = pos,axis = (1,1,0)) trayectoria = curve(color = color.black) velocidadtotal = arrow(color = color.red,pos = proyectil.pos,axis = vel/3.) velocidadx = arrow(color = color.green,pos = proyectil.pos,axis = (vel.x/3.,0,0)) velocidady = arrow(color = color.cyan,pos = proyectil.pos,axis = (0,vel.y/3.,0)) while pos.y >= 0: vel = vel+acel*dt pos = pos+vel*dt trayectoria.append(pos) proyectil.pos = pos velocidadtotal.pos = pos velocidadx.pos = pos velocidady.pos = pos velocidadtotal.axis = vel/3. 23
velocidadx.axis = vector(vel.x/3.,0,0) velocidady.axis = vector(0,vel.y/3.,0) # Linea 5 nueva cinetica.plot(pos=(t,0.5*m*mag2(vel))) potencial.plot(pos=(t,m*grav*proyectil.pos.y)) etotal.plot(pos=(t,m*grav*proyectil.pos.y+0.5*m*mag2(vel))) t = t+dt rate(50) #****************FIN************************** 7.5 Proyectil 3 #! /usr/bin/env python from visual import * # Crear la escena display(title="Proyectiles", width = 600, height=550,background=(0.33,0.7,0.2)) # Crear los tres elementos principales piso = box(pos=(0,-2,0), width =110, height=1, length=10, color= (220.0/255, 181.0/255,134.0/255), axis= (0,0.2,-0.2)) bola1 = sphere(pos=(-25,40,0), radius=1.5, color = color.blue) bola2 = sphere(pos=(-30,40,0), radius=1.5, color = color.red) # Crear espacio para salida de datos alcance=label(pos=(40,-20,0), text="Alcance X") altura= label(pos=(10,-20,0), text="Altura") rapidez= label(pos=(-15,-20,0), text="Rapidez") tiempo= label(pos=(-45,-20,0), text="Tiempo") #de?nicion de la velocidad inicial: proyectil lanzado horizontalmente bola1_velocity_y=0 bola1_velocity_x= 15 b1x=bola1.pos.x b1y=bola1.pos.y pox1= bola1.pos.x poy1= bola1.pos.y #de?nicion de la velocidad inicial: proyectil lanzado horizontalmente bola2_velocity_y=0 bola2_velocity_x= 0 b2x=bola2.pos.x b2y=bola2.pos.y pox2= bola2.pos.x poy2= bola2.pos.y # De?niendo el paso diferencial dt = 0. 24
# Dotando de movimiento esta animacion while 1: rate (20) dt += 0.005 if bola1.pos.y >0.5: #Programando ecuaciones de proyectiles bola1.pos.y= poy1-bola1_velocity_y*dt-4.9*dt**2 bola1.pos.x = pox1 +bola1_velocity_x*dt bola2.pos.y= poy2-bola2_velocity_y*dt-4.9*dt**2 bola2.pos.x = pox2 +bola2_velocity_x*dt # De?niendo la caracteristicas de las trayectorias #Trayectoria: bola 1 curve(pos=[(b1x,b1y,0),(bola1.pos.x, bola1.pos.y,0)], color = color.red, ra- dius=0.3) #Alcance en X curve(pos=[(-30,-10,0),(bola1.pos.x, -10,0)], color = color.red, radius=1) #Trayectoria: bola 2 curve(pos=[(-30,b1y,0),(-30, bola1.pos.y,0)], color = (255.0/255,255.0/255,1.0/255), radius=0.3) # Dando los valores de salida alcance.text="Alcance " + str(round(bola1.pos.x-pox1,2)) + " m" rapide = (bola1_velocity_x**2 + (9.8*dt)**2)**0.5 altura.text="Altura n" + str(round(bola1.pos.y ,2)) + " m" rapidez.text="Rapidez n" + str(round(rapide ,2)) + " m/s" tiempo.text = " Tiempo " + str(round(dt,2)) + " s" b1x=bola1.pos.x b1y=bola1.pos.y #**********************FIN************** 7.6 Suma de dos vectores #! /usr/bin/env python from visual import * #************************************* scene = display(width=500, height=400,center=(5,0,15)) scene.title = ’Suma de dos vectores’ scene.fullscreen = 0 scene.range = (5,1,1) scene.autoscale=0 vector1=arrow(pos=(0,0), axis=(3,3), shaftwidth=0.1, length= 0.01, color=color.green) vector2=arrow(pos=(3,3), axis=(6,1), shaftwidth=0.1, length= 0.01, color=(1,1,0)) 25
vector_resultante=arrow(pos=(0,0,0), axis=(9,4), shaftwidth=0.01, length= 0.01, color=color.red) axis1=mag(vector(3,3)) axis2=mag(vector(6,1)) axis3=mag(vector(9,4)) eje_x= curve(pos=[(0,0,0), (10,0,0)], radius=0.05, color=(0.7,0.3,0.3)) eje_y= curve(pos=[(0,0,0), (0,7,0)], radius=0.05, color=(0.7,0.3,0.3)) i=0 while i <20: rate(10) vector1.length += axis1/20.0 i+=1 i=0 while i <20: rate(10) vector2.length += axis2/20.0 i+=1 i=0 while i <20: rate(10) vector_resultante.length += axis3/20.0 i+=1 print ’la magnitud del vector resultante es = ’, axis3 #**********************FIN************** 7.7 Suma de tres vectores #! /usr/bin/env python from visual import * scene2 = display(title=’Suma de tres vectores’,x=0, y=0, width=600, height=600,center=(10,0,3), background=(0,0,1)) # De?niendo los vectores a sumar y su resultante vector1=arrow(pos=(0,0,0), axis=(3,5,2), shaftwidth=0.1, length= 0.01, co- lor=color.green) vector2=arrow(pos=(3,5,2), axis=(2,-2,4), shaftwidth=0.1, length= 0.01, co- lor=(1,1,0)) vector3=arrow(pos=(5,3,6), axis=(8,3,1), shaftwidth=0.1, length= 0.01, co- lor=color.orange) vector_resultante=arrow(pos=(0,0,0), axis=(13,6,7), shaftwidth=0.01, length= 0.01, color=color.red) axis1=mag(vector(3,5,2)) 26
axis2=mag(vector(2,-2,4)) axis3=mag(vector(8,3,1)) axis4=mag(vector(13,6,7)) #gra?cando sistema de coordenadas eje_x= curve(pos=[(0,0,0), (10,0,0)], radius=0.05, color=(0.7,0.3,0.3)) eje_y= curve(pos=[(0,0,0), (0,10,0)], radius=0.05, color=(0.7,0.3,0.3)) eje_z= curve(pos=[(0,0,0), (0,-1,5)], radius=0.05, color=(0.7,0.3,0.3)) # Valores de salida i=0 while i <20: rate(10) vector1.length += axis1/20.0 i+=1 i=0 while i <20: rate(10) vector2.length += axis2/20.0 i+=1 i=0 while i <20: rate(10) vector3.length += axis3/20.0 i+=1 i=0 while i <20: rate(10) vector_resultante.length += axis4/20.0 i+=1 resultante = label(pos=(10,-5,10), text = "Resultante") resultante.text = ’La magnitud de la resultante es n’ + str(round(axis4,2)) + ’ km’ #******************FIN******************* 27
Referencias [1] Chabay, R. W. and Sherwood, B. A. (2007) Research-based Reform of University Physics, chapter Matter and Interactions. PER-Central. [2] Feynman, R.P., Leighton, R.B. & Sands, M. (1998) Física. Vol I. Pearson Educación. [3] García, C.P. (2008) Proyecto Physthones. Simulaciones Físicas en Visual Python (0.1). Un libro libre de Alqua. [4] García, J.H. & Ferreiro, A. (2005) Representación grá?ca 2D: Matplotlib. www.linux-Magazine.es [5] Marzal, A., Gracia, I. (2003) Introducción a la Programación con Python. Departamento de Lenguajes y Sistemas Informaticos. Universitat Jaume I. [6] Mireles, L.O. (2011) Brevisimo manual para el tratamiento inicial de datos utilizando la plataforma Linux. [7] Piskunov, N. (1978) Calculo Diferencial e Integral. Ed. MIR. Moscu. [8] Sanders, D.P. (2010) Notas del curso: Programación en Python. Curso de actualizaión docente. Facultad de Ciencias. [9] Sears, F.W., Zemansky, M.W., Young, H.D. & Freedman, R.A. (1999) Fí- sica Universitaria. Pearson Educación. [10] Tippens, P.E. (2001) Física: Conceptos y aplicaciones. Ed. McGraw Hill 28