"""

Realizado por:
Juan David Contreras
Escuela de Ingenieria Mecanica
Universidad del Valle
"""
#llamamos librerias a usar
import matplotlib.pyplot as plt
from numpy import *
import math
# definimos constrantes globales
pi = math.pi #numero pi
class Cgrid():
#crear grid para circulo centrado en origen
def __init__(self, div, dist):
self.div = div #numero de viviciones a lo largo del diametro hotizonta
l del circulo
self.dist = dist #distrancia ortogonal entre cada nodo o divicion
self.radio = self.dist*self.div/2 #radio del circulo
self.sgmt = linspace(-self.radio, self.radio, div) #arreglo de las div
iciones
self.r2 = self.radio + self.dist*0.5 #radio de condicion
def N_nodos(self): #funcion que calcula en numero de nodos
sgmt, r2= self.sgmt, self.r2
nodos = 0 #conteo inica desde cero
for i in sgmt:
for j in sgmt:
L = sqrt(i**2 + j**2)
if L < r2:
nodos = nodos +1
return nodos
def grid(self):
#funcion que genera un array con las coordenadas de los puntos del circulo
n = self.N_nodos()
hy, r2 = self.sgmt, self.r2
puntos = zeros((n,2))
#crea arreglo para posicionar coordenadas
nodo = 0
for p in hy:
for m in hy:
L = sqrt(p**2 + m**2)
if L < r2:
puntos[nodo] = [p , m] #asignar coordenada a cada fila
nodo = nodo + 1
return puntos
class XYgrid(Cgrid):
#generalizacion de la clase Cgrid, para circulo con centro en (x,y)
def __init__(self, div, dist):
Cgrid.__init__(self, div, dist)
def xygrid(self, Cx, Cy): #
offset = np.array([Cx, Cy]) #crea vertor de desplazamiento
return Cgrid.grid(self) + offset #desplaza cada punto de el arreglo de c
oordenadas

class VelP():
#clase que calcula la velocidad inducida por la vorticidad de un punto
def __init__(self, diametro, vort):
self.diametro = diametro
self.vort = vort
self.area = pi*((diametro/2)**2)
def vel1(self, Coordenadas, Punto0, Punto1 ):
w, a = self.vort, self.area
dx = Coordenadas[Punto0,0] - Coordenadas[Punto1,0]
dy = Coordenadas[Punto0,1] - Coordenadas[Punto1,1]
velx = -w*a*dy/(2*pi*(dx**2 + dy**2)) #vel en la direccion x
vely = w*a*dx/(2*pi*(dx**2 + dy**2)) #vel en la direccion y
return np.array([velx, vely])
class VelT(VelP):
def __init__(self, diametro, vort):
VelP.__init__(self, diametro, vort)
def vel(self, Coordenadas, Punto, V0=np.array([0,0])):
# velocidad inducida por una coleccion de puntos a una paeticula
N = len(Coordenadas) #numero de filas del arreglo de coordenadas
V = V0
#condcion inicial
for i in range(0,N):
if i != Punto:
V = V + VelP.vel1(self, Coordenadas, Punto, i)
return V
def velT(self, Coordenadas, V0=np.array([0,0])):
#calcular la velocidad de todos las particos inducida por la vorticidad
de las demas
NN = len(Coordenadas)
VT = zeros((NN,2))
for j in range(0,NN):
VT[j] = self.vel(Coordenadas, j, V0)
return VT
class Euler():
def __init__(self, pasos, x0, m, dt):
self.pasos, self.x0, self.m, self.dt = pasos, x0, m, dt
def euler1(self):
#metodod para calcular la paroximacion de un solo paso dt
X1 = self.x0 + self.m*self.dt
return X1
def euler(self, diametro, vort):
pasos, x0, m, dt = self.pasos, self.x0, self.m, self.dt
N = len(x0)
Cor = x0 #coordenadas iniciales
V = VelT(diametro, vort)
for i in range(0,pasos):
#aplica el la apliximacion i veces
for j in range(0, N):
#aplica la aproximacion para cada punto
(x,y)
Cor[j] = Cor[j] + m[j]*dt
m = V.velT(Cor) #recalcula la velocidad en cada nuevo punto para
las nuevas corrdenadas
return Cor

print("Digite el tiempo de simulacion en segundos")

tiempo = input(">") #el usuario ingreso el tiempo al cual quiere visualizar el
movimiento de particulas
print("Digite el intervalo de tiempo dt para la aproximacion de Euler --x(t+dt)=
x(t) + v(t)*dt --")
dt = input(">") #el usuario ingresa el dt para la aproximacion de euler
print("el programa esta calculando...")
plt.axis('equal') #igualar la escala de los ejes
#definimos los puntos del ciculo
Circulo = XYgrid(20, 0.03)
#Puntos del circulo centrado en cero
C1 = Circulo.xygrid(0 , 0.4)
#puntos del circulo centrado en (0,5)
C2 = Circulo.xygrid(0 , -0.4)
#unir los dos arreglos de coordenadas en uno solo con los puntos de los dos circ
ulos
C = numpy.concatenate((C1,C2))
#plt.plot(C1.T[0], C1.T[1], 'r.')
#plt.plot(C2.T[0], C2.T[1], 'r.')
#define un objero VelT --vel total-- con diametro 0.01 y vorticidad -2
d = 0.027 #diametro de los elementos de vorticidad
w = -2
V = VelT(d, w)
vT = V.velT(C) #calcula la velocidad de cada punto de los 2 circulos
#se calcula el desplazamiento con el metodo de Euler
pasos = int(tiempo/dt) #numero de iteracion que utilizaca la aproximacion
#objeto para usar el metodo de euler para el calculo aproximado del desplaxamien
to de las particulas de vorticidad
move = Euler(pasos, C, vT, dt)
move1= move.euler(d, w) #posicion de las particulas en el tiempo t
#grafica de la posicion de las perticulas
plt.plot(move1.T[0], move1.T[1], 'b.') # el .T indica transpuesta