#Problem Variables Declaration
#----------------------------------------------------------------------------------------
longitud = 1 # meters
phi_0 = 1 #intensive property at left boundary
phi_L = 0 #intensive property at right boundary
gamma = 0.1 # kg/ms
rho = 1 # kg/m3
u = 0.2 #m/s
N = 6 # Number of nodes
#----------------------------------------------------------------------------------------
#Mesh creation and mesh parameter definition
#----------------------------------------------------------------------------------------
malla = fvm.Mesh(nodes=N, length=longitud) # Mesh creation
nx = malla.nodes() # Number of nodes
nvx = malla.volumes() # Number of volumes
delta = malla.delta() # Volumes size (grid step)
#----------------------------------------------------------------------------------------
#Problem variables printing
#----------------------------------------------------------------------------------------
fvm.printData(Longitud=longitud,
Propiedad_izquierda=phi_0,
Propiedad_derecha=phi_L,
Conductividad=gamma,
Densidad=rho,
Velocidad=u,
Nodos=nx,
def analyticSol(x):
return ((TB - TA) / longitud + q * (longitud - x) / (2 * k)) * x + TA
#---------Se establecen los parámetros iniciales que definen el problema------
longitud = 0.02 # meters
TA = 100 # °C
TB = 200 # °C
k = 0.5 # W/m.K
q = 1e+06 # 1e+06 W/m^3 = 1000 kW/m^3 Fuente uniforme
N = 6 # Número de nodos
#-----------------------------------------------------------------------------
# Creamos la malla y obtenemos datos importantes
#
malla = fvm.Mesh(nodes=N, length=longitud)
nx = malla.nodes() # Número de nodos
nvx = malla.volumes() # Número de volúmenes
delta = malla.delta() # Tamaño de los volúmenes
#
# Imprimimos los datos del problema (nicely)
#
fvm.printData(Longitud=longitud,
Temperatura_A=TA,
Temperatura_B=TB,
Conductividad=k,
Fuente=q,
Nodos=nx,
Volúmenes=nvx,
Delta=delta)
#
phiL = 0 #
N = 351 # Número de nodos
#valores iniciales del tiempo
t_max = 1.0 #s
dt = 0.002 #s
n_tiempos = t_max / dt + 1
tiempos = np.arange(
0, t_max + dt, dt
) #arreglo que contiene los valores de tiempo donde se evalúa la solución
n_tiempos = len(tiempos)
#------------------------------------------------------
#
# Creamos la malla y obtenemos datos importantes
#
malla = fvm.Mesh(nodes=N, length=L)
nx = malla.nodes() # Número de nodos
nvx = malla.volumes() # Número de volúmenes
delta = malla.delta() # Tamaño de los volúmenes
#
# Imprimimos los datos del problema (nicely)
#
fvm.printData(Longitud=L,
Densidad=rho,
Velocidad=u,
Coef_Diff=Gamma,
Prop_0=phi0,
Prop_L=phiL,
Nodos=nx,
Volúmenes=nvx,
Delta=delta)
# Se puede seleccionar el metodo de aproximacion en las caras
#scheme = 'Upwind'
#scheme = 'CDS'
#scheme = 'Upwind2'
scheme = 'Quick'
# Se puede seleccionar el algoritmo de solucion del sistema de ecuaciones
#algoritmo = 'Default (LU Decomp)'
algoritmo = 'Sparse'
# -------------------------------------
# Se crea la malla
# -------------------------------------
N = N + 1
mesh = fvm.Mesh(nodes=N, length=L)
n_x = mesh.nodes() # Numero de nodos
n_volx = mesh.volumes() # Numero de volumenes
delta = mesh.delta() # Tamaño de volumenes
x = mesh.createMesh() # Vector de coordendas del dominio
# -------------------------------------
# Imprimir Datos del problema
# -------------------------------------
fvm.printData(Longitud=L,
Densidad=rho,
Velocidad=u,
Coef_Diff=Gamma,
Prop_0=phi_0,
Prop_L=phi_L,
Nodos=n_x,
def analyticSol(x):
return (np.exp(rho * u * x / Gamma) - 1) / (np.exp(rho * u * L / Gamma) -
1) * (phiB - phiA) + phiA
# Datos del Problema (Variables)
L = 1.0 # m
rho = 1.0 # kg/m^3
u = 0.1 # m/s
Gamma = 0.1 # kg / m.s
phiA = 1 #
phiB = 0 #
N = 50 # Número de nodos
# Creamos la malla y obtenemos datos importantes
malla = fvm.Mesh(nodes=N, length=L)
nx = malla.nodes() # Número de nodos
nvx = malla.volumes() # Número de volúmenes
delta = malla.delta() # Tamaño de los volúmenes
# Imprimimos los datos del problema (nicely)
fvm.printData(Longitud=L,
Densidad=rho,
Velocidad=u,
Coef_Diff=Gamma,
Prop_0=phiA,
Prop_L=phiB,
Nodos=nx,
Volúmenes=nvx,
Delta=delta)
def analyticSol(x):
return (np.exp(rho * u * x / Gamma) - 1) / (np.exp(rho * u * L / Gamma) - 1) * (phiL - phi0) + phi0
L = 1.0 # m
rho = 0.5 # kg/m^3
u = -0.1 # m/s
Gamma = 0.1 # kg / m.s
phi0 = 1#
phiL = 0 #
phiA=0
phiB=0
N = 20 # Número de nodos
#
# Creamos la malla y obtenemos datos importantes
#
malla = fvm.Mesh2D(nx = N, ny = N, lenx = L, leny = L)
nx, ny = malla.nodes() # Número de nodos
nvx, nvy = malla.volumes() # Número de volúmenes
deltax, deltay = malla.delta() # Tamaño de los volúmenes
#
# Imprimimos los datos del problema (nicely)
#
fvm.printData(Longitud = L,
Densidad = rho,
Velocidad = u,
Coef_Diff = Gamma,
Prop_0 = phi0,
Prop_L = phiL,
NodosX = nx,
Nodosy = ny,
Volumenesx = nvx,
Tb = 500 # °C ---- Frontera derecha
k = 1000 # W/mK
L = 0.5 # m
A = 10e-3 # m^2
N = 5 # Numero de nodos
# Se puede seleccionar el algoritmo de solucion del sistema de ecuaciones
#algoritmo = 'Default (LU Decomp)'
algoritmo = 'Sparse'
# -------------------------------------
# Se crea la malla
# -------------------------------------
N = N + 1
mesh = fvm.Mesh(nodes = N, length = L)
n_x = mesh.nodes() # Numero de nodos
n_volx = mesh.volumes() # Numero de volumenes
delta = mesh.delta() # Tamaño de volumenes
# -------------------------------------
# Imprimir Datos del problema
# -------------------------------------
fvm.printData(Longitud = L,
Coef_Conductividad = k,
Frontera_Izquierda = Ta,
Frontera_Derecha = Tb,
Nodos = n_x,
Volúmenes = n_volx,
Delta = delta)
import FiniteVolumeMethod as fvm
import numpy as np
import matplotlib.pyplot as plt
longitud = 1 # metros
PhiA = 1 #Valor de la propedad en la frontera A
PhiB = 0.000001 #Valor de la propedad en la frontera B
gamma = 0.1 # Gamma
rho = 1 #Kg/m^3
u = 0.1 #m/s
N = 6 # Número de nodos
#
# Creamos la malla y obtenemos datos importantes
#
malla = fvm.Mesh(nodes=N, length=longitud)
nx = malla.nodes() # Número de nodos
nvx = malla.volumes() # Número de volúmenes
delta = malla.delta() # Tamaño de los volúmenes
#
# Imprimimos los datos del problema (nicely)
#
fvm.printData(Longitud=longitud,
Propiedad_A=PhiA,
Propiedad_B=PhiB,
Conductividad=gamma,
Nodos=nx,
Volúmenes=nvx,
Delta=delta)
#
# Creamos los coeficientes de FVM
def analyticSol(x):
return (TA - Tambiente) * np.cosh(N * (longitud - x)) / np.cosh(
N * longitud) + Tambiente
longitud = 1.0 # metros
Tambiente = 20 # °C
TA = 100 # °C
n2 = 25 # /m^2
fluxB = 0.0 # Flujo igual a cero
N = 10 # Número de nodos
#
# Creamos la malla y obtenemos datos importantes
#
malla = fvm.Mesh(nodes=N, length=longitud)
nx = malla.nodes() # Número de nodos
nvx = malla.volumes() # Número de volúmenes
delta = malla.delta() # Tamaño de los volúmenes
#
# Imprimimos los datos del problema (nicely)
#
fvm.printData(Longitud=longitud,
Temperatura_A=TA,
Flujo_B=fluxB,
n2=n2,
Nodos=nx,
Volúmenes=nvx,
Delta=delta)
#
# Creamos los coeficientes de FVM
title_graf = '$\partial \phi / \partial t + \partial(p u \phi)/\partial x= \partial (\Gamma \partial\phi/\partial x)/\partial x$'
# Datos del Problema (Variables)
L = 2.5 # m
rho = 1.0 # kg/m^3
u = 1.0 # m/s
Gamma = 0.001 # kg / m.s
phiA = 1 #
phiB = 0 #
N = 350 # Número de nodos
delta_t = 0.002 # Paso de tiempo
steps = 500
#
# Creamos la malla y obtenemos datos importantes
#
malla = fvm.Mesh(nodes=N, length=L)
nx = malla.nodes() # Número de nodos
nvx = malla.volumes() # Número de volúmenes
delta = malla.delta() # Tamaño de los volúmenes
x = malla.createMesh() # Vector de coordenadas del dominio
#
# Se construye el arreglo donde se guardará la solución
#
phi = np.zeros(nvx) # El arreglo contiene ceros
phi[0] = phiA # Condición de frontera izquierda
phi[-1] = phiB # Condición de frontera derecha
#
# Imprimimos los datos del problema (nicely)
#
fvm.printData(Longitud=L,
Densidad=rho,
import FiniteVolumeMethod as fvm
#Librerias de Python
import numpy as np
import matplotlib.pyplot as plt
# Datos del Problema (Variables)
longitud = 0.5 # metros
TA = 100 # °C
TB = 500 # °C
k = 1000 # W/m.K
N = 6 # Número de nodos
#
# Creamos la malla y obtenemos datos importantes
#
malla = fvm.Mesh(nodes=N, length=longitud)
nx = malla.nodes() # Número de nodos
nvx = malla.volumes() # Número de volúmenes
delta = malla.delta() # Tamaño de los volúmenes
#
# Imprimimos los datos del problema
#
fvm.printData(Longitud=longitud,
Temperatura_A=TA,
Temperatura_B=TB,
Conductividad=k,
Nodos=nx,
Volúmenes=nvx,
Delta=delta)