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={