def test_conexión_horizontal(símismo):
"""
Comprobar que la conexión de variables se haga correctamente con 3 submodelos conectados directamente
en el mismo :class:`SuperConectado`.
"""
# Crear los 3 modelos
bf = EnvolturaBF(arch_bf, nombre='bf')
tercio = ModeloPySD(arch_mod_vacío, nombre='tercio')
mds = ModeloPySD(arch_mds, nombre='mds')
# El Conectado
conectado = SuperConectado()
for m in [bf, mds, tercio]:
conectado.agregar_modelo(m)
# Conectar variables entre dos de los modelos por el intermediario del tercero.
conectado.conectar_vars(var_fuente='Aleatorio',
modelo_fuente='bf',
var_recip='Aleatorio',
modelo_recip='tercio')
conectado.conectar_vars(var_fuente='Aleatorio',
modelo_fuente='tercio',
var_recip='Aleatorio',
modelo_recip='mds')
# Simular
res = conectado.simular(100,
vars_interés=['bf_Aleatorio', 'mds_Aleatorio'])
# Comprobar que los resultados son iguales.
npt.assert_allclose(res['bf_Aleatorio'],
res['mds_Aleatorio'],
rtol=0.001)
def setUpClass(cls):
"""
Preparar los modelos genéricos necesarios para las pruebas.
"""
# Generar las instancias de los modelos individuales y conectados
cls.mods_mds = generar_modelos_prueba()
cls.mod_bf = EnvolturaBF(arch_bf)
cls.modelos = {ll: Conectado()
for ll in cls.mods_mds} # type: dict[str, Conectado]
# Agregar traducciones necesarias.
trads.agregar_trad('year', 'año', leng_trad='es', leng_orig='en')
trads.agregar_trad('month', 'mes', leng_trad='es', leng_orig='en')
# Conectar los modelos
for mds, mod_con in cls.modelos.items():
mod_con.estab_bf(cls.mod_bf)
mod_con.estab_mds(cls.mods_mds[mds])
mod_con.conectar(var_mds='Lluvia',
var_bf='Lluvia',
mds_fuente=False)
mod_con.conectar(var_mds='Lago', var_bf='Lago', mds_fuente=True)
mod_con.conectar(var_mds='Aleatorio',
var_bf='Aleatorio',
mds_fuente=False)
def test_conexión_jerárquica(símismo):
"""
Comprobar que 3 modelos conectados de manera jerárquica a través de 2 :class:`SuperConectados` funcione
bien. No es la manera más fácil o directa de conectar 3+ modelos, pero es importante que pueda funcionar
esta manera también.
"""
# Los tres modelos
bf = EnvolturaBF(arch_bf, nombre='bf')
tercio = ModeloPySD(arch_mod_vacío, nombre='tercio')
mds = ModeloPySD(arch_mds, nombre='mds')
# El primer Conectado
conectado_sub = SuperConectado(nombre='sub')
conectado_sub.agregar_modelo(tercio)
conectado_sub.agregar_modelo(mds)
conectado_sub.conectar_vars(
var_fuente='Aleatorio', modelo_fuente='tercio',
var_recip='Aleatorio', modelo_recip='mds'
)
# El segundo Conectado
conectado = SuperConectado()
conectado.agregar_modelo(bf)
conectado.agregar_modelo(conectado_sub)
conectado.conectar_vars(
var_fuente='Aleatorio', modelo_fuente='bf',
var_recip='tercio_Aleatorio', modelo_recip='sub'
)
# Correr la simulación
res = conectado.simular(100, vars_interés=['bf_Aleatorio', 'sub_mds_Aleatorio'])
# Verificar que los resultados sean iguales.
npt.assert_allclose(res['bf_Aleatorio'], res['sub_mds_Aleatorio'], rtol=0.001)
def test_nombre_inválido(símismo):
"""
Asegurarse que nombres inválidos para modelos se corrijan automáticamente.
"""
mod = EnvolturaBF(arch_bf, nombre='Nombre_inválido')
símismo.assertNotIn('_', mod.nombre)
def setUpClass(cls):
# Generar la Envoltura BF
cls.envltmodelo = EnvolturaBF(arch_bf)
# Información sobre los variables del modelo de prueba
cls.info_vars = {
'Lluvia': {'unidades': 'm3/año', 'líms': (0, None), 'val_inic': 2.3},
'Lago': {'unidades': 'm3', 'líms': (0, None)},
'Escala': {'unidades': '', 'líms': (0, None)},
'Vacío': {'unidades': 'm3/año', 'líms': (0, None), 'val_inic': 15}
} # type: dict[str, dict]
# Iniciar variables
vals_inic = {vr: d['val_inic'] for vr, d in cls.info_vars.items() if 'val_inic' in d}
# Correr el modelo para 200 pasos, guardando los egresos del variable "Lago"
cls.envltmodelo.simular(t_final=200, vals_inic=vals_inic, vars_interés=['Escala', 'Lluvia'])
def estab_bf(símismo, bf):
"""
Establece el modelo biofísico (:class:`~tinamit.BF.EnvolturasBF`).
:param bf: El fuente con la clase del modelo biofísico. **Debe** ser un fuente de Python.
:type bf: str | EnvolturaBF
"""
# Creamos una instancia de la Envoltura BF con este modelo.
if isinstance(bf, str) or isinstance(bf, ModeloBF) or callable(bf):
modelo_bf = EnvolturaBF(modelo=bf)
elif isinstance(bf, EnvolturaBF):
modelo_bf = bf
else:
raise TypeError(_('Debes dar o un modelo BF, o la dirección hacia el fuente de uno.'))
# Conectamos el modelo biofísico.
símismo.agregar_modelo(modelo=modelo_bf)
# Y guardamos la referencia rápida.
símismo.bf = modelo_bf
def test_crear_desde_modelobf(símismo):
# Comprobar creación de la envoltura directamente desde un modelo BF.
modelo_bf = ModeloPrueba()
envlt = EnvolturaBF(modelo_bf)
símismo.assertIsInstance(envlt, EnvolturaBF)
def test_crear_desde_clase(símismo):
# Comprobar creación de la envoltura desde una clase de modelo BF.
envlt = EnvolturaBF(ModeloPrueba)
símismo.assertIsInstance(envlt, EnvolturaBF)
def test_crear_desde_archivo(símismo):
# Comprobar creación de la envoltura desde un fuente que contiene un modelo BF.
envlt = EnvolturaBF(arch_bf)
símismo.assertIsInstance(envlt, EnvolturaBF)
def setUpClass(cls):
cls.mod = EnvolturaBF(arch_bf_flexible)