MAESTRIA EN CIENCIAS

MATEMATICAS
APLICADAS E INDUSTRIALES
TALLER DE MODELADO I
Alumna: Pe
na Tellez Leticia.
4 de Julio del 2012.

1.

Programa de Fuerza Social con el m

etodo de Runge-Kutta de
orden 2

En el programa que se tena de Fuerza Social se resolva el sistema de ecuaciones con el metodo de Euler, se
le hizo una modificaci
on para resolver el sistema con el metodo de Runge-Kutta de segundo orden. La parte
del programa que se modifico se hizo de la siguiente manera:
En la funci
on Persona(entra,sale,n) se agregaron las siguientes caractersticas:
Ind[i].vant =array([0.000001,0.000001]), que guarda la velocidad de prediccion para cada peaton.
Ind[i].Posant= array(EyS[entra] + y*array([0,1]))
Ind[i].Posant = array(EyS[entra] + y*array([1,0])), estas u
ltimas guardan la posicion de predicci
on de
cada peat
on.
Adem
as se agrego el arreglo:
ant=zeros((2,300)), que es la suma de las fuerzas totales necesaria para la prediccion de la velocidad.
Primero se obtiene la suma de las fuerzas totales para cada peaton y se calcula de la siguiente manera:
for i in NP:
for j in range(i+1,p):
dij=P[i].Pos - P[j].Pos
b = mag(dij)
if b < 3:
f = (Vo)*(exp((P[i].radius + P[j].radius - b)/desv))*(dij/b)
Fij[:,i] = Fij[:,i] + (lamda1 + (1-lamda1)*( (1 + dot(P[i].di,dij/b) )/2))*f
1

Fij[:,j] = Fij[:,j] - (lamda1 + (1-lamda1)*( (1 + dot(P[j].di,dij/b) )/2))*f

#----------Fuerza de movimiento----------#
Fi = (P[i].rd*P[i].di - P[i].v)/ta
#----------Fuerza de repulsion a muros-----------#
Fim =(Uo/R)*exp(-(5. - abs(P[i].pos.y) - P[i].radius)/R)*array([0,-copysign(1,P[i].pos.y)])
#----------Calculo de la aceleracion----------#
ant[:,i]=Fi + Fim + Fij[:,i]
la cual es ant[:,i] pues es la que se utiliza para calcular la velocidad y posicion de prediccion como sigue:

#------------Actualizacion de posiciones y eliminacion de peatones----------

Control.interact()
runge kutta de orden 2
P[i].vant = P[i].v + ant[:,i]*dt
P[i].r = mag(P[i].vant)
if P[i].r > P[i].rmax:
P[i].vant = (P[i].vant/P[i].r)*P[i].rmax
P[i].r = P[i].rmax
P[i].pos = P[i].Posant + P[i].vant*dt
P[i].Posant = array([P[i].pos.x, P[i].pos.y])

Para calcular la velocidad y posici

on de correccion necesitamos las suma de las fuerzas totales, que es a[:,i]
y se realiza de la siguiente manera:
# calcular a para el siguiente tiempo ------------------------for j in range(i+1,p):
dij=P[i].Posant - P[j].Posant
b = mag(dij)
if b < 3:
f = (Vo)*(exp((P[i].radius + P[j].radius - b)/desv))*(dij/b)
Fij[:,i] = Fij[:,i] + (lamda1 + (1-lamda1)*( (1 + dot(P[i].di,dij/b) )/2))*f
Fij[:,j] = Fij[:,j] - (lamda1 + (1-lamda1)*( (1 + dot(P[j].di,dij/b) )/2))*f
#----------Calculo de direccion----------#
#P[i].di = (P[i].PosK[0] - P[i].Pos)/mag(P[i].PosK[0] - P[i].Pos)
#----------Fuerza de movimiento----------#
Fi = (P[i].rd*P[i].di - P[i].vant)/ta
#----------Fuerza de repulsion a muros-----------#
Fim =(Uo/R)*exp(-(5. - abs(P[i].pos.y) - P[i].radius)/R)*array([0,-copysign(1,P[i].pos.y)])
#----------Calculo de la aceleracion----------#
a[:,i]=Fi + Fim + Fij[:,i]
P[i].v = P[i].v + (ant[:,i]+ a[:,i])*dt/2
a[:,i]=[0,0]
Fij[:,i]=[0,0]
P[i].r = mag(P[i].v)
if P[i].r > P[i].rmax:
2

P[i].v = (P[i].v/P[i].r)*P[i].rmax
P[i].r = P[i].rmax
#P[i].radius=P[i].r/3
P[i].pos = P[i].Posant + (P[i].vant + P[i].v)*dt/2
P[i].Pos = array([P[i].pos.x, P[i].pos.y])

El resto del programa queda igual y es el siguiente:

from time import sleep
from visual import *
from visual.controls import *
from visual.graph import *
from numpy import fmod
from random import choice, gauss, randint
#from numpy.random import permutation

#---------------Transparencias de paredes---------------#
def transparencia(valor):
for i in W:
i.opacity=valor/100.
#---------------Contruye las paredes---------------#
def Construye(x):
W=[box(pos=(0,0,-0.6),size=(2*x[0,0],2*abs(x[0,1]),0.2),color=mycolor, opacity=opacidad)]
for i in range(x.shape[0]-1):
a = x[i,1];l=-1
if x[i+1,1] > x[i,1]:
a = x[i+1,1];l=1
if abs(x[i+1,0] - x[i,0])!=0 and abs(x[i+1,1] - x[i,1])!=0:
W.append(box(pos=(x[i,0] + (abs(x[i+1,0] - x[i,0]))/2. , a - (abs(x[i+1,1]-x[i,1]))/2. , 2.5-0.6),size=(sqrt(pow(x[i+1,0]-x[i,0],2) + pow(x[i+1,1]-x[i,1],2)),0.2,5),axis=(abs(x[i+1,0]-x[i,0])*l
W.append(box(pos=(-x[i,0] - (abs(x[i+1,0] - x[i,0]))/2. ,a - (abs(x[i+1,1]-x[i,1]))/2. , 2.5-0.6),size=(sqrt(pow(x[i+1,0]-x[i,0],2) + pow(x[i+1,1]-x[i,1],2)),0.2,5),axis=(abs(x[i+1,0]-x[i,0])*l
W.append(box(pos=(x[i,0] + (abs(x[i+1,0] - x[i,0]))/2. , -a +(abs(x[i+1,1]-x[i,1]))/2. , 2.5-0.6),size=(sqrt(pow(x[i+1,0]-x[i,0],2) + pow(x[i+1,1]-x[i,1],2)),0.2,5),axis=(-abs(x[i+1,0]-x[i,0])*
W.append(box(pos=(-x[i,0] - (abs(x[i+1,0] - x[i,0]))/2. , -a +(abs(x[i+1,1]-x[i,1]))/2. , 2.5-0.6),size=(sqrt(pow(x[i+1,0]-x[i,0],2) + pow(x[i+1,1]-x[i,1],2)),0.2,5),axis=(-abs(x[i+1,0]-x[i,0])
k=0
for j in linspace(x[i,0],x[i+1,0],30):
W.append(box(pos=(j,0,-0.6),size=(abs(x[i+1,0]-x[i,0])/30.,2*x[i,1] + l*k*2*abs(x[i+1,1]-x[i,1])/30.,0.2),color=mycolor,opacity=opacidad))
W.append(box(pos=(-j,0,-0.6),size=(abs(x[i+1,0]-x[i,0])/30.,2*x[i,1] + l*k*2*abs(x[i+1,1]-x[i,1])/30.,0.2),color=mycolor,opacity=opacidad))
k+=1
else:
W.append(box(pos=(x[i,0] + (abs(x[i+1,0] - x[i,0]))/2. , a - (abs(x[i+1,1]-x[i,1]))/2. , 2.5-0.6),size=(abs(x[i,0]-x[i+1,0]) + abs(x[i,1]-x[i+1,1]),0.2,5),axis=(abs(x[i+1,0]-x[i,0]),abs(x[i+1,1
W.append(box(pos=(-x[i,0] - (abs(x[i+1,0] - x[i,0]))/2. ,a - (abs(x[i+1,1]-x[i,1]))/2. , 2.5-0.6),size=(abs(x[i,0]-x[i+1,0]) + abs(x[i,1]-x[i+1,1]),0.2,5),axis=(abs(x[i+1,0]-x[i,0]),-abs(x[i+1,
W.append(box(pos=(x[i,0] + (abs(x[i+1,0] - x[i,0]))/2. , -a+(abs(x[i+1,1]-x[i,1]))/2. , 2.5-0.6),size=(abs(x[i,0]-x[i+1,0]) + abs(x[i,1]-x[i+1,1]),0.2,5),axis=(-abs(x[i+1,0]-x[i,0]),abs(x[i+1,1
W.append(box(pos=(-x[i,0] - (abs(x[i+1,0] - x[i,0]))/2. , -a+(abs(x[i+1,1]-x[i,1]))/2. , 2.5-0.6),size=(abs(x[i,0]-x[i+1,0]) + abs(x[i,1]-x[i+1,1]),0.2,5),axis=(-abs(x[i+1,0]-x[i,0]),-abs(x[i+1
W.append(box(pos=(x[i,0] +(abs(x[i+1,0] - x[i,0]))/2. ,0,-0.6),size=(abs(x[i,0]-x[i+1,0]),2*abs(x[i+1,1]),0.2),axis=(-abs(x[i+1,0]-x[i,0]),-abs(x[i+1,1]-x[i,1]),0), color=mycolor, opacity=opaci
W.append(box(pos=(-x[i,0] -(abs(x[i+1,0] - x[i,0]))/2. ,0,-0.6),size=(abs(x[i,0]-x[i+1,0]),2*abs(x[i+1,1]),0.2),axis=(-abs(x[i+1,0]-x[i,0]),-abs(x[i+1,1]-x[i,1]),0), color=mycolor, opacity=opac
return W
#---------------Construccion de peatones----------------#
def Persona(entra,sale,n):
Ind=[]
col=[color.blue,color.red,color.white,color.cyan]
Entra=random.permutation(24)
for i in range(n):
Ind.append(sphere())
Ind[i].radius=0.4
Ind[i].color=col[entra]
Ind[i].di=array([1,0])
Ind[i].v=array([.000001,.000001])
Ind[i].vant =array([0.000001,0.000001])
Ind[i].r=mag(Ind[i].v)
Ind[i].a=array([0,0])
Ind[i].rd=gauss(1.34,0.26)
Ind[i].rmax=1.3*Ind[i].rd
while 1:
y = gauss(0,Ancho[entra]/3)
if abs(y) < Ancho[entra]/2.:
if EyS[entra,1] == 0:
Ind[i].pos=vector(EyS[entra] + y*array([0,1]))
Ind[i].Pos=array(EyS[entra] + y*array([0,1]))
Ind[i].Posant = array(EyS[entra] + y*array([0,1]))
else:
Ind[i].pos=vector(EyS[entra] + y*array([1,0]))
Ind[i].Pos=array(EyS[entra] + y*array([1,0]))
Ind[i].Posant = array(EyS[entra] + y*array([1,0]))
break
Ind[i].PosK = [EyS[sale], 100*(EyS[sale]/mag(EyS[sale]))]
i+=1
return Ind
#Estas son las propiedades de la pantalla que se esplejara. Pantalla completa es: fullscreen=1
myscene=display(title=Simulacin de flujo peatonal,x=0,y=0,width=600,height=280,center=(0,0,0),autoscale=1)
#lamp = local_light( pos = (0,0,15), color = (.6,.6,0.3) )
#----------Piso paredes y etiquetas----------#
opacidad=0.6
mycolor=color.gray(0.5)
#Entradas y Salidas
#EyS=array([[-25,0],[25,0],[25/sqrt(2), 25/sqrt(2)],[-25/sqrt(2),-25/sqrt(2)]])
EyS=array([[-25,0],[25,0]])
#Ancho de entrada
Ancho=[10,10]
x=array([[0,5],[25,5]])
largo=2*max(x[:,0])

ancho=2*min(x[:,1])
tamX=x.size/2
W=Construye(x)
#------------------Datos iniciales-----------------#
P=[]
#:=Caracteristicas de los Peatones
lamda1=0.7
#:=Parametro
Vo=2.5
#:=Fuerza de Iteracion entre peatones
desv=0.5
#:=Rango de Iteracion
Uo=10.
#:=Fuerza de Iteracion entre los muros
R=0.2
#:=Rango de Iteracion
ta=0.5
#:=Relajacion
dt=0.2
#:=Intervalo de Tiempo
tk=0

#:=Tiempo inicial

a=zeros((2,300))
ant=zeros((2,300))
Fij=zeros((2,300))
Fim = array([0,0])
k=0
NP=[]
p=0
Puertas=[0,1]
l2=label(pos=(0,8,7),text=No. de peatones en el pasillo: +str(p))
###########----------COMIENZA LA SIMULACION----------###########
raw_input(Presione cualquier tecla)
while 1:
#Entrada de peatones
if not fmod(k,1/dt):
for Entra in [0]:
n=randint(0,10)
Salida=Entra
while Salida == Entra:
Salida=choice(Puertas)
P=append(P,Persona(Entra, Salida, n))
p+=n
NP=range(p)
l2.text=No. de peatones en el pasillo: +str(p)
#----------Calculo de fuerzas entre peatones----------#
for i in NP:
for j in range(i+1,p):
dij=P[i].Pos - P[j].Pos
b = mag(dij)
if b < 3:
f = (Vo)*(exp((P[i].radius + P[j].radius - b)/desv))*(dij/b)
Fij[:,i] = Fij[:,i] + (lamda1 + (1-lamda1)*( (1 + dot(P[i].di,dij/b) )/2))*f
Fij[:,j] = Fij[:,j] - (lamda1 + (1-lamda1)*( (1 + dot(P[j].di,dij/b) )/2))*f
#----------Calculo de direccion----------#
#P[i].di = (P[i].PosK[0] - P[i].Pos)/mag(P[i].PosK[0] - P[i].Pos)
#----------Fuerza de movimiento----------#
Fi = (P[i].rd*P[i].di - P[i].v)/ta
#----------Fuerza de repulsion a muros-----------#
Fim =(Uo/R)*exp(-(5. - abs(P[i].pos.y) - P[i].radius)/R)*array([0,-copysign(1,P[i].pos.y)])
#----------Calculo de la aceleracion----------#
ant[:,i]=Fi + Fim + Fij[:,i]
#print------------Actualizacion de posiciones y eliminacion de peatones----------
#
Control.interact()
runge kutta de orden 2
P[i].vant = P[i].v + ant[:,i]*dt
P[i].r = mag(P[i].vant)
if P[i].r > P[i].rmax:
P[i].vant = (P[i].vant/P[i].r)*P[i].rmax
P[i].r = P[i].rmax
P[i].pos = P[i].Posant + P[i].vant*dt
P[i].Posant = array([P[i].pos.x, P[i].pos.y])
# calcular a para el siguiente tiempo ------------------------for j in range(i+1,p):
dij=P[i].Posant - P[j].Posant
b = mag(dij)
if b < 3:
f = (Vo)*(exp((P[i].radius + P[j].radius - b)/desv))*(dij/b)
Fij[:,i] = Fij[:,i] + (lamda1 + (1-lamda1)*( (1 + dot(P[i].di,dij/b) )/2))*f
Fij[:,j] = Fij[:,j] - (lamda1 + (1-lamda1)*( (1 + dot(P[j].di,dij/b) )/2))*f
#----------Calculo de direccion----------#
#P[i].di = (P[i].PosK[0] - P[i].Pos)/mag(P[i].PosK[0] - P[i].Pos)
#----------Fuerza de movimiento----------#
Fi = (P[i].rd*P[i].di - P[i].vant)/ta
#----------Fuerza de repulsion a muros-----------#
Fim =(Uo/R)*exp(-(5. - abs(P[i].pos.y) - P[i].radius)/R)*array([0,-copysign(1,P[i].pos.y)])
#----------Calculo de la aceleracion----------#
a[:,i]=Fi + Fim + Fij[:,i]
P[i].v = P[i].v + (ant[:,i]+ a[:,i])*dt/2
a[:,i]=[0,0]
Fij[:,i]=[0,0]
P[i].r = mag(P[i].v)
if P[i].r > P[i].rmax:
P[i].v = (P[i].v/P[i].r)*P[i].rmax
P[i].r = P[i].rmax
#P[i].radius=P[i].r/3
P[i].pos = P[i].Posant + (P[i].vant + P[i].v)*dt/2
P[i].Pos = array([P[i].pos.x, P[i].pos.y])
if mag(P[i].Pos - P[i].PosK[0]) < 2:
P[i].PosK = delete(P[i].PosK,0,axis=0)

if abs(P[i].pos.x) >= largo/2 or abs(P[i].pos.y) >= largo/2:

P[i].visible = 0 #Borra de pantalla
P=delete(P,i)
#Elimina del conjunto de peatones
del NP[p-1]
#Elimina el ultimo del arreglo para el for
p-=1
#Elimina del contador
if myscene.mouse.clicked:
m = myscene.mouse.getclick()
myscene.pos=m.pos
k+=1
###########----------FIN LA SIMULACION----------###########

A diferencia del programa que se resuelve con el metodo de Euler, este tarda mas tiempo pues se calculan 2
veces las fuerzas totales.
Para saber que el programa se esta ejecutando correctamente, se hizo una comparacion con los resultados
obtenidos con cada uno de los metodos y para dt = 0,2 y dt = 0,1. Se observa mejor si se reduce el n
umero
de peatones que entran a 1, y se hace en un n
umero finito de pasos (lo que implica que el tiempo es finito).
Para mostrar los resultados se le hicieron las siguientes modificaciones al programa:
A las caractersticas del peat
on se le agregaron: Ind[i].v1,Ind[i].vant1 e Ind[i].Posant1.
Se aumentan las aceleraciones a1 y ant1.
Para hacer que se comparen los resultados con dt = 0,2 y dt = 0,1, el proceso con dt = 0,1 se tiene que
duplicar para avanzar lo mismo que dt = 0,2 en el mismo paso, por lo que el proceso descrito arriba se
repite 3 veces, una con dt = 0,2 y 2 mas para dt = 0,1
El programa que muestra las comparaciones es el siguiente:
from time import sleep
from visual import *
from visual.controls import *
from visual.graph import *
from numpy import fmod
from random import choice, gauss, randint
#from numpy.random import permutation

#---------------Transparencias de paredes---------------#
def transparencia(valor):
for i in W:
i.opacity=valor/100.
#---------------Contruye las paredes---------------#
def Construye(x):
W=[box(pos=(0,0,-0.6),size=(2*x[0,0],2*abs(x[0,1]),0.2),color=mycolor, opacity=opacidad)]
for i in range(x.shape[0]-1):
a = x[i,1];l=-1
if x[i+1,1] > x[i,1]:
a = x[i+1,1];l=1
if abs(x[i+1,0] - x[i,0])!=0 and abs(x[i+1,1] - x[i,1])!=0:
W.append(box(pos=(x[i,0] + (abs(x[i+1,0] - x[i,0]))/2. , a - (abs(x[i+1,1]-x[i,1]))/2. , 2.5-0.6),size=(sqrt(pow(x[i+1,0]-x[i,0],2) + pow(x[i+1,1]-x[i,1],2)),0.2,5),axis=(abs(x[i+1,0]-x[i,0])*l
W.append(box(pos=(-x[i,0] - (abs(x[i+1,0] - x[i,0]))/2. ,a - (abs(x[i+1,1]-x[i,1]))/2. , 2.5-0.6),size=(sqrt(pow(x[i+1,0]-x[i,0],2) + pow(x[i+1,1]-x[i,1],2)),0.2,5),axis=(abs(x[i+1,0]-x[i,0])*l
W.append(box(pos=(x[i,0] + (abs(x[i+1,0] - x[i,0]))/2. , -a +(abs(x[i+1,1]-x[i,1]))/2. , 2.5-0.6),size=(sqrt(pow(x[i+1,0]-x[i,0],2) + pow(x[i+1,1]-x[i,1],2)),0.2,5),axis=(-abs(x[i+1,0]-x[i,0])*
W.append(box(pos=(-x[i,0] - (abs(x[i+1,0] - x[i,0]))/2. , -a +(abs(x[i+1,1]-x[i,1]))/2. , 2.5-0.6),size=(sqrt(pow(x[i+1,0]-x[i,0],2) + pow(x[i+1,1]-x[i,1],2)),0.2,5),axis=(-abs(x[i+1,0]-x[i,0])
k=0
for j in linspace(x[i,0],x[i+1,0],30):
W.append(box(pos=(j,0,-0.6),size=(abs(x[i+1,0]-x[i,0])/30.,2*x[i,1] + l*k*2*abs(x[i+1,1]-x[i,1])/30.,0.2),color=mycolor,opacity=opacidad))
W.append(box(pos=(-j,0,-0.6),size=(abs(x[i+1,0]-x[i,0])/30.,2*x[i,1] + l*k*2*abs(x[i+1,1]-x[i,1])/30.,0.2),color=mycolor,opacity=opacidad))
k+=1
else:
W.append(box(pos=(x[i,0] + (abs(x[i+1,0] - x[i,0]))/2. , a - (abs(x[i+1,1]-x[i,1]))/2. , 2.5-0.6),size=(abs(x[i,0]-x[i+1,0]) + abs(x[i,1]-x[i+1,1]),0.2,5),axis=(abs(x[i+1,0]-x[i,0]),abs(x[i+1,1
W.append(box(pos=(-x[i,0] - (abs(x[i+1,0] - x[i,0]))/2. ,a - (abs(x[i+1,1]-x[i,1]))/2. , 2.5-0.6),size=(abs(x[i,0]-x[i+1,0]) + abs(x[i,1]-x[i+1,1]),0.2,5),axis=(abs(x[i+1,0]-x[i,0]),-abs(x[i+1,
W.append(box(pos=(x[i,0] + (abs(x[i+1,0] - x[i,0]))/2. , -a+(abs(x[i+1,1]-x[i,1]))/2. , 2.5-0.6),size=(abs(x[i,0]-x[i+1,0]) + abs(x[i,1]-x[i+1,1]),0.2,5),axis=(-abs(x[i+1,0]-x[i,0]),abs(x[i+1,1
W.append(box(pos=(-x[i,0] - (abs(x[i+1,0] - x[i,0]))/2. , -a+(abs(x[i+1,1]-x[i,1]))/2. , 2.5-0.6),size=(abs(x[i,0]-x[i+1,0]) + abs(x[i,1]-x[i+1,1]),0.2,5),axis=(-abs(x[i+1,0]-x[i,0]),-abs(x[i+1
W.append(box(pos=(x[i,0] +(abs(x[i+1,0] - x[i,0]))/2. ,0,-0.6),size=(abs(x[i,0]-x[i+1,0]),2*abs(x[i+1,1]),0.2),axis=(-abs(x[i+1,0]-x[i,0]),-abs(x[i+1,1]-x[i,1]),0), color=mycolor, opacity=opaci
W.append(box(pos=(-x[i,0] -(abs(x[i+1,0] - x[i,0]))/2. ,0,-0.6),size=(abs(x[i,0]-x[i+1,0]),2*abs(x[i+1,1]),0.2),axis=(-abs(x[i+1,0]-x[i,0]),-abs(x[i+1,1]-x[i,1]),0), color=mycolor, opacity=opac
return W
#---------------Construccion de peatones----------------#
def Persona(entra,sale,n):
Ind=[]
col=[color.blue,color.red,color.white,color.cyan]
Entra=random.permutation(24)
for i in range(n):
Ind.append(sphere())
Ind[i].radius=0.4
Ind[i].color=col[entra]
Ind[i].di=array([1,0])
Ind[i].v=array([.000001,.000001])
Ind[i].vant =array([0.000001,0.000001])
Ind[i].v1=array([.000001,.000001])
Ind[i].vant1 =array([0.000001,0.000001])
Ind[i].r=mag(Ind[i].v)
Ind[i].a=array([0,0])
Ind[i].rd=gauss(1.34,0.26)

Ind[i].rmax=1.3*Ind[i].rd
while 1:
y = gauss(0,Ancho[entra]/3)
if abs(y) < Ancho[entra]/2.:
if EyS[entra,1] == 0:
Ind[i].pos=vector(EyS[entra] + y*array([0,1]))
Ind[i].Pos=array(EyS[entra] + y*array([0,1]))
Ind[i].Posant = array(EyS[entra] + y*array([0,1]))
Ind[i].Posant1 = array(EyS[entra] + y*array([0,1]))
else:
Ind[i].pos=vector(EyS[entra] + y*array([1,0]))
Ind[i].Pos=array(EyS[entra] + y*array([1,0]))
Ind[i].Posant = array(EyS[entra] + y*array([1,0]))
Ind[i].Posant1 = array(EyS[entra] + y*array([1,0]))
break
Ind[i].PosK = [EyS[sale], 100*(EyS[sale]/mag(EyS[sale]))]
i+=1
return Ind
#Estas son las propiedades de la pantalla que se esplejara. Pantalla completa es: fullscreen=1
myscene=display(title=Simulacin de flujo peatonal,x=0,y=0,width=600,height=280,center=(0,0,0),autoscale=1)
#lamp = local_light( pos = (0,0,15), color = (.6,.6,0.3) )
#----------Piso paredes y etiquetas----------#
opacidad=0.6
mycolor=color.gray(0.5)
#Entradas y Salidas
#EyS=array([[-25,0],[25,0],[25/sqrt(2), 25/sqrt(2)],[-25/sqrt(2),-25/sqrt(2)]])
EyS=array([[-25,0],[25,0]])
#Ancho de entrada
Ancho=[10,10]
x=array([[0,5],[25,5]])
largo=2*max(x[:,0])
ancho=2*min(x[:,1])
tamX=x.size/2
W=Construye(x)
#------------------Datos iniciales-----------------#
P=[]
#:=Caracteristicas de los Peatones
lamda1=0.7
#:=Parametro
Vo=2.5
#:=Fuerza de Iteracion entre peatones
desv=0.5
#:=Rango de Iteracion
Uo=10.
#:=Fuerza de Iteracion entre los muros
R=0.2
#:=Rango de Iteracion
ta=0.5
#:=Relajacion
dt=0.2
#:=Intervalo de Tiempo
dt1=0.1
tk=0 #:=Tiempo inicial
a=zeros((2,300))
a1=zeros((2,300))
ant=zeros((2,300))
ant1=zeros((2,300))
Fij=zeros((2,300))
Fim = array([0,0])
k=0
NP=[]
p=0
Puertas=[0,1]
l2=label(pos=(0,8,7),text=No. de peatones en el pasillo: +str(p))
###########----------COMIENZA LA SIMULACION----------###########
raw_input(Presione cualquier tecla)
s=0
print \n Iteracin \t Vel con Euler \t Vel con Runge-Kutta
while s<20:
print \n,s
#Entrada de peatones
if not fmod(k,1/dt):
for Entra in [0]:
n=1
Salida=Entra
while Salida == Entra:
Salida=choice(Puertas)
P=append(P,Persona(Entra, Salida, n))
p+=n
NP=range(p)
l2.text=No. de peatones en el pasillo: +str(p)
#----------Calculo de fuerzas entre peatones----------#
for i in NP:
for j in range(i+1,p):
dij=P[i].Pos - P[j].Pos
b = mag(dij)
if b < 3:
f = (Vo)*(exp((P[i].radius + P[j].radius - b)/desv))*(dij/b)
Fij[:,i] = Fij[:,i] + (lamda1 + (1-lamda1)*( (1 + dot(P[i].di,dij/b) )/2))*f
Fij[:,j] = Fij[:,j] - (lamda1 + (1-lamda1)*( (1 + dot(P[j].di,dij/b) )/2))*f
#----------Calculo de direccion----------#
#P[i].di = (P[i].PosK[0] - P[i].Pos)/mag(P[i].PosK[0] - P[i].Pos)
#----------Fuerza de movimiento----------#
Fi = (P[i].rd*P[i].di - P[i].v)/ta
#----------Fuerza de repulsion a muros-----------#
Fim =(Uo/R)*exp(-(5. - abs(P[i].pos.y) - P[i].radius)/R)*array([0,-copysign(1,P[i].pos.y)])
#----------Calculo de la aceleracion----------#
#a[:,i]=Fi + Fim + Fij[:,i]
ant[:,i]=Fi + Fim + Fij[:,i]
ant1[:,i]=Fi + Fim + Fij[:,i]
#print------------Actualizacion de posiciones y eliminacion de peatones----------
#
Control.interact()
runge kutta de orden 2
#-------------dt=0.2-----------------------------P[i].vant = P[i].v + ant[:,i]*dt
P[i].r = mag(P[i].vant)
if P[i].r > P[i].rmax:

P[i].vant = (P[i].vant/P[i].r)*P[i].rmax
P[i].r = P[i].rmax
P[i].pos = P[i].Posant + P[i].vant*dt
P[i].Posant = array([P[i].pos.x, P[i].pos.y])
#for i in NP:
# calcular a para el siguiente tiempo ------------------------print \n peaton: ,i
for j in range(i+1,p):
dij=P[i].Posant - P[j].Posant
b = mag(dij)
if b < 3:
f = (Vo)*(exp((P[i].radius + P[j].radius - b)/desv))*(dij/b)
Fij[:,i] = Fij[:,i] + (lamda1 + (1-lamda1)*( (1 + dot(P[i].di,dij/b) )/2))*f
Fij[:,j] = Fij[:,j] - (lamda1 + (1-lamda1)*( (1 + dot(P[j].di,dij/b) )/2))*f
#----------Calculo de direccion----------#
#P[i].di = (P[i].PosK[0] - P[i].Pos)/mag(P[i].PosK[0] - P[i].Pos)
#----------Fuerza de movimiento----------#
Fi = (P[i].rd*P[i].di - P[i].vant)/ta
#----------Fuerza de repulsion a muros-----------#
Fim =(Uo/R)*exp(-(5. - abs(P[i].pos.y) - P[i].radius)/R)*array([0,-copysign(1,P[i].pos.y)])
#----------Calculo de la aceleracion----------#
a[:,i]=Fi + Fim + Fij[:,i]
P[i].v = P[i].v + (ant[:,i]+ a[:,i])*dt/2
a[:,i]=[0,0]
Fij[:,i]=[0,0]
P[i].r = mag(P[i].v)
if P[i].r > P[i].rmax:
P[i].v = (P[i].v/P[i].r)*P[i].rmax
P[i].r = P[i].rmax
#P[i].radius=P[i].r/3
if s<20:
print \n t = , dt*s , \t,P[i].vant,\t,P[i].v
#print \n ,P[i].vant,\t,P[i].v,\t,P[i].vant-P[i].v
#------------------------------dt=0.1------mm=0
while mm<2:
P[i].vant1 = P[i].v1 + ant1[:,i]*dt1
P[i].r = mag(P[i].vant1)
if P[i].r > P[i].rmax:
P[i].vant1 = (P[i].vant1/P[i].r)*P[i].rmax
P[i].r = P[i].rmax
P[i].pos = P[i].Posant1 + P[i].vant1*dt1
P[i].Posant1 = array([P[i].pos.x, P[i].pos.y])
#for i in NP:
# calcular a para el siguiente tiempo ------------------------for j in range(i+1,p):
dij=P[i].Posant1 - P[j].Posant1
b = mag(dij)
if b < 3:
f = (Vo)*(exp((P[i].radius + P[j].radius - b)/desv))*(dij/b)
Fij[:,i] = Fij[:,i] + (lamda1 + (1-lamda1)*( (1 + dot(P[i].di,dij/b) )/2))*f
Fij[:,j] = Fij[:,j] - (lamda1 + (1-lamda1)*( (1 + dot(P[j].di,dij/b) )/2))*f
#----------Calculo de direccion----------#
#P[i].di = (P[i].PosK[0] - P[i].Pos)/mag(P[i].PosK[0] - P[i].Pos)
#----------Fuerza de movimiento----------#
Fi = (P[i].rd*P[i].di - P[i].vant1)/ta
#----------Fuerza de repulsion a muros-----------#
Fim =(Uo/R)*exp(-(5. - abs(P[i].pos.y) - P[i].radius)/R)*array([0,-copysign(1,P[i].pos.y)])
#----------Calculo de la aceleracion----------#
a1[:,i]=Fi + Fim + Fij[:,i]
P[i].v1 = P[i].v1 + (ant1[:,i]+ a1[:,i])*dt1/2
a1[:,i]=[0,0]
Fij[:,i]=[0,0]
P[i].r = mag(P[i].v1)
if P[i].r > P[i].rmax:
P[i].v1 = (P[i].v1/P[i].r)*P[i].rmax
P[i].r = P[i].rmax
#P[i].radius=P[i].r/3
if s<20 and mm==1:
print \n t = ,2*s*dt1, \t,P[i].vant1,\t,P[i].v1
#print \n,mag(P[i].vant-P[i].vant1),\t,mag(P[i].v-P[i].v1)
mm+=1
#----------------P[i].pos = P[i].Posant + (P[i].vant + P[i].v)*dt/2
P[i].Pos = array([P[i].pos.x, P[i].pos.y])
s+=1
if mag(P[i].Pos - P[i].PosK[0]) < 2:
P[i].PosK = delete(P[i].PosK,0,axis=0)
if abs(P[i].pos.x) >= largo/2 or abs(P[i].pos.y) >= largo/2:
P[i].visible = 0 #Borra de pantalla
P=delete(P,i)
#Elimina del conjunto de peatones
del NP[p-1]
#Elimina el ultimo del arreglo para el for
p-=1
#Elimina del contador
if myscene.mouse.clicked:
m = myscene.mouse.getclick()
myscene.pos=m.pos
k+=1
###########----------FIN LA SIMULACION----------###########

Una parte de los resultados obtenidos con este programa son los siguientes, donde para cada peaton el primer
rengl
on es con dt = 0,2 y el segundo es con dt = 0,1
Iteracin

Velocidad con el metodo de Euler

Velocidad con el metodo de Runge-Kutta

0
peaton:

t =

0.0

4.71265211e-01

-7.89336817e-07]

3.77012369e-01

-4.31468905e-07]

t =

0.0

4.47702001e-01

-6.99869994e-07]

4.02931901e-01

-5.29882891e-07]

1
peaton:

t =

0.2

6.97472033e-01

-1.64821621e-06]

6.33380100e-01

-1.40486603e-06]

t =

0.2

7.04776628e-01

-1.67595162e-06]

6.72000202e-01

-1.55150324e-06]

2
peaton:

t =

0.4

8.51292671e-01

-2.23225093e-06]

8.07710157e-01

-2.06677346e-06]

t =

0.4

8.75155135e-01

-2.32285562e-06]

8.50977631e-01

-2.23105670e-06]

3
peaton:

t =

0.6

9.55890706e-01

-2.62939142e-06]

9.26254596e-01

-2.51686749e-06]

t =

0.6

9.87422405e-01

-2.74911603e-06]

9.69451180e-01

-2.68088189e-06]

4
peaton:

t =

0.8

1.02701737e+00

-2.89944360e-06]

1.00686481e+00

-2.82292815e-06]

t =

0.8

1.06085616e+00

-3.02792843e-06]

1.04739600e+00

-2.97682249e-06]

5
peaton:

t =

1.0

[ 1.08747084 -0.02385858]

t =

1.0

[ 1.1198772 -0.0235033]

peaton:

[ 1.0773244

-0.03074381]

[ 1.10855436 -0.02126128]

t =

1.2

[ 0.41845403

0.07077164]

[ 0.33476342

0.05559484]

t =

1.2

[ 0.40952126

0.04244342]

[ 0.38055912

0.01325726]

peaton:

t =

1.4

[ 1.12871628 -0.03919813]

[ 1.12398009 -0.04710085]

t =

1.4

[ 1.15441377 -0.03070566]

[ 1.14678078 -0.03046678]

peaton:

t =

1.6

[ 0.62207128

0.08379526]

[ 0.56460971

0.07782313]

t =

1.6

[ 0.66022195

0.02432284]

[ 0.63897603

0.00740154]

Notamos que las velocidades son muy parecidas con dt distintos y se notan ciertas diferencias con metodos
distintos. Por ejemplo donde se tiene:
3
peaton:

t =

0.6

9.55890706e-01

-2.62939142e-06]

9.26254596e-01

-2.51686749e-06]

t =

0.6

9.87422405e-01

-2.74911603e-06]

9.69451180e-01

-2.68088189e-06]

se ve que se tiene una muy buena aproximacion a las velocidades con dt distintas, pues para el metodo de
Runge-Kutta las diferencias entre las velocidades para cada una de las coordenas es 0.0043196583999999955
y 1.6401440000000018e-07.
La diferencia entre un metodo y otro con dt = 0,2 es [-0.002963611000000005,1.1252392999999997e-07].
La diferencia entre un metodo y otro con dt = 0,1 es [0.001797122499999998,-6.82341399999998e-08].
Por lo tanto si queremos tener una mejor aproximacion a los resultados convendra usar el metodo de RungeKutta, pero si queremos ahorrar tiempo en el n
umero de operaciones es mejor usar el metodo de Euler.