from utils.displayInfo import printInfo
from geo.line import Line
import numpy as np
rod = Line(0.5)
malla = rod.constructMesh(5)
ivx,_,_ = malla.bounds(bi = 1, ei = 4)
su = np.ones(ivx)
u = np.ones(malla.vx)
ns = NumericalScheme(malla, su, dt = 4.4)
# ns = NumericalScheme(dx = 1.0, dy = 2.3, dz = 3.4, dt 0.9)
printInfo(Descripcion = 'Prueba de NumericalScheme()',
dx = ns.dx,
dy = ns.dy,
dz = ns.dz,
dt = ns.dt)
class nsTest(NumericalScheme):
def __init__(self, mesh, Su, gamma=1.0):
super().__init__(mesh, Su)
self.__Gamma = gamma
def calc(self, i):
print('i:',i,'dx = ', self.dx)
ns_test = nsTest(malla, su)
printInfo(Descripcion = 'Prueba de nsTest()',
nvx = malla.vx # Número de volúmenes
delta = malla.dx # Tamaño de los volúmenes
#
# Se construye el arreglo donde se guardará la solución
#
T = np.ones(nvx + 2) # El arreglo contiene unos
T *= TA # Inicializamos T = TA
T[0] = TA # Condición de frontera izquierda
T[-1] = TB # Condición de frontera derecha
#
# Imprimimos los datos del problema (nicely)
#
printInfo(Longitud=longitud,
Temperatura_A=TA,
Temperatura_B=TB,
Conductividad=k,
Nodos=nx,
Volúmenes=nvx,
Delta=delta)
print(T)
#
# Definimos la fuente
#
Su = np.zeros(ivx)
Su[:] = q
#
# Definimos el esquema de disccretización
#
dif_scheme = tDiffusion1D(malla, Su, dt=dt, Gamma=k)
#
# Definimos la ecuación a resolver
if __name__ == '__main__':
from utils.displayInfo import printInfo
from geo.line import Line
from geo.rectangle import Rectangle
N = 6 # Nodos
barra = Line(1.0)
malla = barra.constructMesh(N)
ivx, _, _ = malla.bounds(bi = 1, ei = N-1)
su = np.ones(ivx)
laplace = sDiffusion1D(malla, su)
laplace.Gamma = 2.0
printInfo(Descr = 'Testing Diffusion1D',
dx = laplace.dx,
vx = malla.vx)
print(laplace.calc(3))
print(laplace.source(su))
cuadro = Rectangle(1,1)
malla2 = cuadro.constructMesh(N,N)
ivx, ivy, _ = malla2.bounds(bi = 1, ei = N-1, bj = 1, ej = N-1)
su = np.ones((ivy, ivx))
laplace2 = sDiffusion2D(malla2, su)
printInfo(Descr = 'Testing Diffusion2D',
dx = laplace2.dx,
dy = laplace2.dy,
vx = malla.vx,
vy = malla.vy)
print(laplace2.calc(3,4))
def calc(self, i):
print('Test calc()', i)
return -1, 2, -1
Nx = 10
#
# Create a mesh
#
malla = uMesh(nx = Nx, lx = 1)
ivx, _, _ = malla.bounds(bi = 1, ei = Nx - 1)
printInfo(Descr = 'Malla de prueba',
Test = 'Mesh(nodes_x = %d, length_x = %f)' % (malla.nx, malla.lx),
nodes_x = malla.nx,
volumes_x = malla.vx,
length_x = malla.lx,
delta_x = malla.dx,
ivx = ivx)
#
# Create a test scheme to try a LinearSystem
#
scheme_test = Test()
u = np.zeros(malla.vx+2)
#
# Create a LinearSystem
#
LinearSystem(malla, scheme_test)
LinearSystem.constructMat()
self.__b = b
print('MyDomain.__init__(%f, %f)' % (a,b))
def longitud(self):
"""
Ejemplo de un método de la clase.
"""
longitud = self.__b - self.__a
return longitud
# Crea una clase de tipo Domain e imprime sus atributos
dom = Domain()
printInfo(Mesh = dom.mesh,
Dirichlet = dom.dirichlet,
Neumman = dom.neumman,
Dim = dom.dim)
# Crea una clase de tipo MyDomain e imprime sus atributos
t = MyDomain(1.2342,2.00123)
t.mesh = "hola"
t.dirichlet = {'RIGHT':10, 'LEFT':5}
t.neumman = {'RIGHT_WALL':'D', 'LEFT_WALL':'D'}
t.dim = '1D'
printInfo(Mesh = t.mesh,
Dirichlet = t.dirichlet,
Neumman = t.neumman,
Dim = t.dim,
Longitud = t.longitud())
#----------------------- TEST OF THE MODULE ----------------------------------
nvx = malla.vx # Número de volúmenes
nvy = malla.vy # Número de volúmenes
dx = malla.dx # Tamaño de los volúmenes
dy = malla.dy # Tamaño de los volúmenes
xv, yv, _ = malla.coordinatesMeshFVM()
xd, yd, _ = malla.coordinatesMeshFDM()
xg, yg = np.meshgrid(xv, yv, sparse=False)
xg_u, yg_u = np.meshgrid(xd,yv,sparse=True)
xg_v, yg_v = np.meshgrid(xv,yd,sparse=True)
#
# Imprimimos los datos del problema (nicely)
#
printInfo(Longitud_x = longitud_x,
Longitud_y = longitud_y,
Conductividad = k,
Nodos = (nx,ny),
Volúmenes = (nvx,nvy),
Deltas = (dx,dy),
Inner = (ivx, ivy))
#
# A vector field
#
A = 1.0
alpha = 2.0
uvel = -A * np.cos(np.pi * alpha * yg_u) * np.sin(np.pi * alpha * xg_u)
vvel = A * np.sin(np.pi * alpha * yg_v) * np.cos(np.pi * alpha * xg_v)
uvel_v = -A * np.cos(np.pi * alpha * yg_v) * np.sin(np.pi * alpha * xg_u)
vvel_v = A * np.sin(np.pi * alpha * yg_v) * np.cos(np.pi * alpha * xg_u)
#
# Initial concentration
#
-------
None.
"""
pass
#----------------------- TEST OF THE MODULE ----------------------------------
if __name__ == '__main__':
from utils.displayInfo import printInfo #pynoxtli_license_path
m1 = Mesh()
printInfo(Test='Mesh()',
nx=m1.nodes(),
vx=m1.volumes(),
lx=m1.lengths(),
dx=m1.deltas(),
dim=m1.dim)
m1 = Mesh(nx=5)
printInfo(Test='Mesh(nx = 5)',
nx=m1.nodes(),
vx=m1.volumes(),
lx=m1.lengths(),
dx=m1.deltas(),
dim=m1.dim)
m1 = Mesh(vx=8)
printInfo(Test='Mesh(vx = 8)',
nx=m1.nodes(),
vx=m1.volumes(),
#
malla = placa.constructMesh(Nx, Ny)
ivx, ivy, _ = malla.bounds(bi=1, ei=Nx - 1, bj=1, ej=Ny - 1)
nx = malla.nx # Número de nodos
ny = malla.ny # Número de nodos
nvx = malla.vx # Número de volúmenes
nvy = malla.vy # Número de volúmenes
dx = malla.dx # Tamaño de los volúmenes
dy = malla.dy # Tamaño de los volúmenes
#
# Imprimimos los datos del problema (nicely)
#
printInfo(Longitud_x=longitud_x,
Longitud_y=longitud_y,
TL_TR_TT_TB=(TL, TR, TT, TB),
Conductividad=k,
Nodos=(nx, ny),
Volúmenes=(nvx, nvy),
Deltas=(dx, dy),
Inner=(ivx, ivy))
#
# Visualización usando VisCoFlow
#
axis_par = [{'aspect': 'equal'}, {'aspect': 'equal'}]
#
# Visualización de la malla
#
v1 = flx.Plotter(1, 2, axis_par)
v1.plot_mesh(1, malla, vol='.', nod='|')
#
x, y, _ = malla.coordinatesMeshFVM()
#
-------
None.
"""
pass
#----------------------- TEST OF THE MODULE ----------------------------------
if __name__ == '__main__':
from utils.displayInfo import printInfo
m1 = uMesh()
printInfo(Test = 'uMesh()',
nx = m1.nodes(),
vx = m1.volumes(),
lx = m1.lengths(),
dx = m1.deltas(),
dim = m1.dim)
m1.setNodes(nx = 21)
printInfo(Test = 'm1.setNodes(nx = 21)',
nx = m1.nodes(),
vx = m1.volumes(),
lx = m1.lengths(),
dx = m1.deltas(),
dim = m1.dim)
m1.setVolumes(vx = 12)
printInfo(Test = 'm1.setVolumes(nx = 12)',
nx = m1.nodes(),
vx = m1.volumes(),
malla = placa.constructMesh(Nx, Ny)
ivx, ivy, _ = malla.bounds(bi=1, ei=Nx - 1, bj=1, ej=Ny - 1)
nx = malla.nx # Número de nodos
ny = malla.ny # Número de nodos
nvx = malla.vx # Número de volúmenes
nvy = malla.vy # Número de volúmenes
dx = malla.dx # Tamaño de los volúmenes
dy = malla.dy # Tamaño de los volúmenes
#
# Imprimimos los datos del problema (nicely)
#
printInfo(Longitud_x=longitud_x,
Longitud_y=longitud_y,
TL_TT=(TL, TT),
FR_FB=(FR, FB),
Conductividad=k,
Nodos=(nx, ny),
Volúmenes=(nvx, nvy),
Deltas=(dx, dy),
Inner=(ivx, ivy))
#
# Visualización usando VisCoFlow
#
axis_par = [{'aspect': 'equal'}]
v = flx.Plotter(1, 2, axis_par)
v.plot_mesh(1, malla, vol='.')
x, y, _ = malla.coordinatesMeshFVM()
#xg, yg = np.meshgrid(x, y)
#
# Se construye el arreglo donde se guardará la solución
from utils.displayInfo import printInfo
from geo.line import Line
from geo.rectangle import Rectangle
N = 6
rod = Line(1.0)
dt = 0.1
malla = rod.constructMesh(N)
ivx, _, _ = malla.bounds(bi = 1, ei = N-1)
su = np.ones(ivx)
laplace = tDiffusion1D(malla, su, Gamma = 3.4, dt = dt)
u = np.ones(malla.vx+2)
printInfo(Descr = 'Testing tDiffusion1D',
dx = laplace.dx,
vx = malla.vx,
ivx = malla.ivx,
dt = laplace.dt)
print(laplace.calc(3))
print(laplace.source(u))
cuadro = Rectangle(1,1)
malla2 = cuadro.constructMesh(N,N)
ivx, ivy, _ = malla2.bounds(bi = 1, ei = N-1,bj = 1, ej = N-1)
su = np.ones((ivy, ivx))
laplace2 = tDiffusion2D(malla2, su, Gamma=5, dt = dt)
u = np.ones((malla2.vy+2, malla2.vx+2))
printInfo(Descr = 'Testing Diffusion2D',
dx = laplace2.dx,
dy = laplace2.dy,
vx = malla2.vx,
pass
#----------------------- TEST OF THE MODULE ----------------------------------
if __name__ == '__main__':
from utils.displayInfo import printInfo
x = np.linspace(0, 1, 11)
y = np.linspace(0, 2, 5)
z = np.linspace(0, 3, 9)
mesh1D = nMesh(x)
printInfo(Descr='Plot a 1D mesh',
Test='nMesh(x)',
nx=mesh1D.nx,
vx=mesh1D.vx,
lx=mesh1D.lx,
x=mesh1D.x,
dim=mesh1D.dim)
mesh2D = nMesh(x, y)
printInfo(Descr='Plot a 2D mesh',
Test='nMesh(x, y)',
nx_ny=(mesh2D.nx, mesh2D.ny),
vx_vy=(mesh2D.vx, mesh2D.vy),
lx_ly=(mesh2D.lx, mesh2D.ly),
x=mesh2D.x,
y=mesh2D.y,
dim=mesh2D.dim)
mesh3D = nMesh(x, y, z)
Nx = 5
bi = 1
ei = Nx
test_scheme = Test()
#
# Construct a CSR_FVM_ijk matrix
#
A = CSR_FVM_ijk_1D(bi, ei)
A.construct(test_scheme)
A.correct() # Esta función se usa para corregir algunos valores
# En las aplicaciones esta función es sustitutida por aquella que
# calcula las condiciones de frontera.
A.printMat(nice=False)
printInfo(AA=A.AA, JA=A.JA, IA=A.IA)
A.printMat(nice=True)
from scipy.sparse import csr_matrix
#
# Construct a CSR matrix from scipy using the arrays from CSR_FVM_ijk matrix
#
B = csr_matrix((A.AA, A.JA, A.IA))
#
# Now matrices A and B share the memory.
#
# B[1,1] = 3
# A.printMat(nice=True)
print(B)
ivx, _, _ = malla.bounds(bi=1, ei=N - 1)
nx = malla.nx # Número de nodos
nvx = malla.vx # Número de volúmenes
delta = malla.dx # Tamaño de los volúmenes
#
# Se construye el arreglo donde se guardará la solución
#
T = np.zeros(nvx + 2) # El arreglo contiene ceros
T[0] = TA # Condición de frontera izquierda
#
# Imprimimos los datos del problema (nicely)
#
printInfo(Longitud=longitud,
Temperatura_A=TA,
Flujo_B=fluxB,
n2=n2,
Nodos=nx,
Volúmenes=nvx,
Delta=delta)
#
# Definimos la fuente
#
Su = np.zeros(ivx)
Su[:] = n2 * Tambiente
#
# Definimos el esquema de disccretización
#
dif_scheme = sDiffusion1D(malla, Su, Gamma=k)
dif_scheme.Sp(-n2)
#
# Definimos la ecuación a resolver
nvx = malla.vx # Número de volúmenes
delta = malla.dx # Tamaño de los volúmenes
#
# Se construye el arreglo donde se guardará la solución
#
phi = np.zeros(nvx + 2) # El arreglo contiene ceros
phi[0] = phi0 # Condición de frontera izquierda
phi[-1] = phiL # Condición de frontera derecha
#
# Imprimimos los datos del problema (nicely)
#
printInfo(Longitud=L,
phi_A=phi0,
phi_B=phiL,
Gamma=Gamma,
rho=rho,
Nodos=nx,
Volúmenes=nvx,
Delta=delta,
ivx=ivx)
#
# Definimos la fuente
#
Su = np.zeros(ivx)
#
# Definimos el esquema de disccretización
#
ad_scheme = tAdvDiff1D(malla, Su, dt=dt, Gamma=Gamma, rho=rho)
vel = np.zeros(nvx + 2)
vel.fill(u)
print(vel)
if __name__ == '__main__':
from utils.displayInfo import printInfo
from geo.line import Line
N = 6
rod = Line(1.0)
malla = rod.constructMesh(N)
ivx, _, _ = malla.bounds(bi=1, ei=N - 1)
su = np.ones(ivx)
vel = np.ones(ivx)
laplace = sAdvDiff1D(malla, su)
laplace.setVelocity(vel)
printInfo(Descr='Testing Diffusion1D', dx=laplace.dx, vx=malla.vx)
print(laplace.calc(3))
print(laplace.source(su))
# from geo.Rectangle import Rectangle
# cuadro = Rectangle(1,1)
# malla2 = cuadro.constructMesh(N,N)
# ivx, ivy, _ = malla2.bounds(bi = 1, ei = N-1,bj = 1, ej = N-1)
# su = np.ones((ivy, ivx))
# laplace2 = Diffusion2D(malla2, su)
# printTest(Descr = 'Testing Diffusion2D', hx = laplace2.hx, hy = laplace2.hy,
# vx = malla.vx, vy = malla.vy)
# print(laplace2.calc(3,4))
# print(laplace2.source(su))
'ylim':(4100.0,-100), 'xlim':(0,800)}]
v = flx.Plotter(1,1,axis_par)
line, = v.plot(1,T,z, {'marker':'', 'ls':'-', 'lw':0.75})
#v.plot(1,T_ini,z_ini, {'marker':'o', 'ls':'-','label':'Temp. inicial (datos)'})
v.plot(1,T_ini_int,z, {'marker':'', 'ls':'-', 'lw':2.5})
#v.plot(1,T_fin,z_fin, {'marker':'o', 'ls':'-','label':'Temp. final (datos)'})
v.plot(1,T_fin_int,z, {'marker':'', 'ls':'-', 'lw':2.5})
#
# Imprimimos los datos del problema (nicely)
#
printInfo(Longitud = longitud,
Temperatura_A = TA,
Temperatura_B = TB,
Nodos = nx,
Volúmenes = nvx,
dx = dx,
dt = dt,
Tmax = Tmax)
#
# Definimos la fuente
#
Su = np.zeros(ivx)
#
# Definimos el esquema de disccretización
#
acoculco = tDiffusion1D(malla, Su, dt = dt)
acoculco.calcConductivity()
#acoculco.Gamma = 1.0e-7
#v.plot(1,acoculco.Gamma*5000,z, {'marker':'.','color':'b', 'ls':'-', 'lw':1})
print(acoculco.Gamma)
if dirichlet == None:
dirichlet = { }
if neumman == None:
neumman = { }
Domain.dirichlet = dirichlet
Domain.neumman = neumman
#----------------------- TEST OF THE MODULE ----------------------------------
if __name__ == '__main__':
from utils.displayInfo import printInfo
# Crea una línea de longitud = 8,
linea = Line(8)
printInfo(Length = linea.length)
# Construye la malla de la línea con 9 nodos.
linea.constructMesh(9)
mesh = linea.mesh
printInfo(Descr = 'Construcción de una malla en 1D',
Code = 'Mesh(nodes_x = {}, length_x = {})'.format(mesh.nx, mesh.lx),
nodos_x = mesh.nx,
volumes_x = mesh.vx,
length_x = mesh.lx,
delta_x = mesh.dx)
# Se pueden agregar condiciones de frontera a la línea:
linea.boundaryConditions(dirichlet = {'LEFT':20, 'RIGHT':10})
printInfo(Descr = 'Condiciones de frontera en la línea',
BC_Dirichlet = linea.dirichlet,
if dirichlet == None:
dirichlet = {}
if neumman == None:
neumman = {}
Domain.dirichlet = dirichlet
Domain.neumman = neumman
#----------------------- TEST OF THE MODULE ----------------------------------
if __name__ == '__main__':
from utils.displayInfo import printInfo
cuadro = Rectangle(5, 4)
printInfo(Length_x=cuadro.length_x, Length_y=cuadro.length_y)
cuadro.constructMesh(6, 5)
mesh = cuadro.mesh
printInfo(Descr='Construcción de la malla en 2D',
nodes_x=mesh.nx,
nodes_y=mesh.ny,
volumes_x=mesh.vx,
volumes_y=mesh.vy,
length_x=mesh.lx,
length_y=mesh.ly,
delta_x=mesh.dx,
delta_y=mesh.dy)
# Se pueden agregar condiciones de frontera al dominio:
cuadro.boundaryConditions(dirichlet={
