def verificar_leer_egr(cls):
try:
arch_egr, arch_ref = cls.refs_prb_leer_egr()
except NotImplementedError:
return
egr = cls.leer_arch_resultados(arch_egr)
try:
ref = cargar_json(arch_ref)
except FileNotFoundError:
avisar(
_('\nNo encontramos diccionario con los valores corectos de referencia para comprobar que el'
'\nmodelo sí esté leyendo bien los archivos de egresos. Lo generaremos con base en el los valores'
'\nactualmente leídos por el modelo. Asegúrate que los valores generados en'
'\n\t"{}"'
'\nestén correctos, y si no lo son, bórralo. En el futuro, se empleará este fuente para '
'\ncomprobar la función de lectura de egresos.').format(
arch_ref))
for var, val in egr.items():
if isinstance(val, np.ndarray):
egr[var] = val.tolist()
guardar_json(egr, arch=arch_ref)
ref = egr
for var in ref:
npt.assert_equal(ref[var], egr[var], err_msg=var)
def verificar_inic_dic_vals(cls):
try:
arch_inic, arch_ref = cls.refs_prb_vals_inic()
except NotImplementedError:
return
mod = cls(arch_inic)
try:
ref = cargar_json(arch_ref)
except FileNotFoundError:
avisar(
_('\nNo encontramos diccionario con los valores corectos de referencia para comprobar que el'
'\nmodelo sí esté leyendo bien los datos iniciales. Lo generaremos con base en el los valores'
'\nactualmente leídos por el modelo. Asegúrate que los valores generados en'
'\n\t"{}"'
'\nestén correctos, y si no lo son, bórralo. En el futuro, se empleará este fuente para '
'\ncomprobar la función de lectura de datos iniciales.').
format(arch_ref))
d_vals = copiar_profundo(mod.variables)
for d_v in d_vals.values():
if isinstance(d_v['val'], np.ndarray):
d_v['val'] = d_v['val'].tolist()
guardar_json(d_vals, arch=arch_ref)
ref = d_vals
for var in mod.variables:
npt.assert_equal(ref[var]['val'],
mod.obt_val_actual_var(var),
err_msg=var)
def verificar_avanzar(cls, n_pasos=3):
try:
arch_ref = cls.refs_prb_avanzar()
arch_inic = cls.refs_prb_vals_inic()[0]
except NotImplementedError:
return
mod = cls(archivo=arch_inic)
res = mod.simular(t_final=n_pasos)
try:
ref = xr.Dataset.from_dict(cargar_json(arch_ref))
except FileNotFoundError:
avisar(
_('\nNo encontramos diccionario con los valores corectos de referencia para comprobar que el'
'\nmodelo sí esté simulando correctamente. Lo generaremos con base en el los valores'
'\nactualmente leídos por el modelo. Asegúrate que los valores generados en'
'\n\t"{}"'
'\nestén correctos, y si no lo son, bórralo. En el futuro, se empleará este fuente para '
'\ncomprobar la función de simulación de modelo.').format(
arch_ref))
guardar_json(res.to_dict(), arch=arch_ref)
ref = res
xr.testing.assert_equal(ref, res)
def cargar_ref_avanzar(cls, arch_ref, res):
"""
Parameters
----------
arch_ref :
res : xr.DataSet
Returns
-------
"""
try:
return xr.Dataset.from_dict(cargar_json(arch_ref))
except FileNotFoundError:
avisar(
_('\nNo encontramos diccionario con los valores corectos de referencia para comprobar que el'
'\nmodelo sí esté simulando correctamente. Lo generaremos con base en el los valores'
'\nactualmente leídos por el modelo. Asegúrate que los valores generados en'
'\n\t"{}"'
'\nestén correctos, y si no lo son, bórralo. En el futuro, se empleará este fuente para '
'\ncomprobar la función de simulación de modelo.').format(
arch_ref))
guardar_json(res.to_dict(), arch=arch_ref)
return res
def cargar_ref_ejemplo_vals_inic(símismo):
if not os.path.isfile(símismo.dic_prb_datos_inic):
avisar(_('\nNo encontramos diccionario con los valores corectos de referencia para comprobar que el'
'\nmodelo sí esté leyendo bien los datos iniciales. Lo generaremos con base en el los valores'
'\nactualmente leídos por el modelo. Asegúrate que los valores generados en'
'\n\t"{}"'
'\nestén correctos, y si no lo son, bórralo. En el futuro, se empleará este fuente para '
'\ncomprobar la función de lectura de datos iniciales.').format(símismo.dic_prb_datos_inic))
d_vals = copiar_profundo(símismo.variables)
for d_v in d_vals.values():
if isinstance(d_v['val'], np.ndarray):
d_v['val'] = d_v['val'].tolist()
guardar_json(d_vals, arch=símismo.dic_prb_datos_inic)
return cargar_json(símismo.dic_prb_datos_inic)
def cargar_ref_ejemplo_egr(símismo):
if not os.path.isfile(símismo.dic_prb_egr):
avisar(_('\nNo encontramos diccionario con los valores corectos de referencia para comprobar que el'
'\nmodelo sí esté leyendo bien los egresos de modelos. Lo generaremos con base en el los valores'
'\nactualmente leídos por el modelo. Asegúrate que los valores generados en'
'\n\t"{}"'
'\nestén correctos, y si no lo son, bórralo. En el futuro, se empleará este fuente para '
'\ncomprobar la función de lectura de egresos.').format(símismo.dic_prb_egr))
d_egr = símismo.leer_archivo_egr(n_años_egr=1, archivo=símismo.prb_arch_egr)
for var, val in d_egr.items():
if isinstance(val, np.ndarray):
d_egr[var] = val.tolist()
guardar_json(d_egr, arch=símismo.dic_prb_egr)
d_egr = cargar_json(símismo.dic_prb_egr)
return d_egr
def cargar_ref_vals_inic(cls, arch_ref, mod):
try:
return cargar_json(arch_ref)
except FileNotFoundError:
avisar(
_('\nNo encontramos diccionario con los valores corectos de referencia para comprobar que el'
'\nmodelo sí esté leyendo bien los datos iniciales. Lo generaremos con base en el los valores'
'\nactualmente leídos por el modelo. Asegúrate que los valores generados en'
'\n\t"{}"'
'\nestén correctos, y si no lo son, bórralo. En el futuro, se empleará este fuente para '
'\ncomprobar la función de lectura de datos iniciales.').
format(arch_ref))
d_vals = copiar_profundo(mod.variables)
for d_v in d_vals.values():
if isinstance(d_v['val'], np.ndarray):
d_v['val'] = d_v['val'].tolist()
guardar_json(d_vals, arch=arch_ref)
return d_vals
def guardar(símismo):
guardar_json(símismo.apli.receta, arch=símismo.apli.ubic_archivo)