versión 1.3.0 publicada

.gitignore

@@ -6,7 +6,7 @@
 *.tmp
 
 # Código compilado #
-###################
+####################
 __pycache__/
 
 # Archivos de Python #
@@ -27,6 +27,8 @@ docs/.tx/*
 # Archivos de VENSIM #
 ######################
 *.vdf
+*.2mdl
+*.3vm
 
 # Archivos de Tinamït #
 #######################
@@ -37,6 +39,12 @@ docs/.tx/*
 *.frq
 *.gwt
 *.out
-*.inp
 *.lst
-
+*SAHYSMOD.inp
+*/Ejemplos/**/*SAHYSMOD/NAME*
+*/Ejemplos/**/*SAHYSMOD/*.txt
+*/EnvolturaBF/**/*SAHYSMOD/*.txt
+
+# Archivos temporarios de Excel #
+#################################
+~$*.xlsx*

setup.py

@@ -238,7 +238,7 @@ def instalar_requísitos():
                      'sistemas (MDS). Es muy útil para proyectos de modelización participativa, especialmente'
                      'en proyectos de manejo del ambiente. El interaz gráfico traducible facilita la adopción por'
                      'comunidades en cualquier parte del mundo.',
-    requires=['numpy', 'matplotlib', 'scipy', 'taqdir'],
+    requires=['numpy', 'matplotlib', 'scipy', 'taqdir', 'python-dateutil', 'pandas'],
     classifiers=[
         'Programming Language :: Python :: 3.5',
         'Programming Language :: Python :: 3.6',

tinamit/BF.py

@@ -1,9 +1,12 @@
+import math as mat
 import os
 import sys
 from importlib import import_module as importar_mod
+from warnings import warn as avisar
 
-import math as mat
 import numpy as np
+import datetime as ft
+from dateutil.relativedelta import relativedelta as deltarelativo
 
 from tinamit.Modelo import Modelo
 from .Unidades.Unidades import convertir
@@ -112,7 +115,7 @@ def iniciar_modelo(símismo, **kwargs):
 
         # Aplicar valores iniciales antes de la inicialización del modelo. Simplemente llamamos la función
         # símismo.cambiar_vals() con el diccionario de valores iniciales.
-        símismo.cambiar_vals(símismo.vals_exo['inic'])
+        símismo.cambiar_vals(símismo.vals_inic)
 
         # ...y inicializar el modelo.
         símismo.modelo.iniciar_modelo(**kwargs)
@@ -237,7 +240,7 @@ def __init__(símismo):
         símismo.n_estaciones = 12
         símismo.dur_estaciones = [1] * 12
 
-        #
+        # Un diccionario de variables de ingreso, egreso, y variables estacionales de cada tipo.
         símismo.tipos_vars = {
             'Ingresos': [], 'Egresos': [], 'IngrEstacionales': [], 'EgrEstacionales': []
         }
@@ -256,13 +259,14 @@ def __init__(símismo):
         símismo.estación = 0
         símismo.mes = 0
 
-        # Creamos un diccionario para guardar valores de variables para cada paso. Tiene el formato siguiente:
-        # {'var 1': [valorpaso1, valorpaso2, ...],
-        #  'var 2': [valorpaso1, valorpaso2, ...],
+        # Creamos un diccionario para guardar valores de variables para cada estación. Tiene el formato siguiente:
+        # {'var 1': [valorestación1, valorestación2, ...],
+        #  'var 2': [valorestación1, valorestación2, ...],
         #  ...
         #  }
         símismo.datos_internos = {var: None for var in símismo.variables if var in símismo.tipos_vars['Estacionales']}
 
+        # Leer los valores iniciales
         símismo.leer_vals_inic()
 
     def cambiar_vals_modelo_interno(símismo, valores):
@@ -275,6 +279,10 @@ def cambiar_vals_modelo_interno(símismo, valores):
         :type valores: dict
 
         """
+        pass
+
+        """
+        ESTO NO ES NECESARIO DADO LOS ENLACES DINÁMICOS, YO PIENSO (VERIFICAR).
 
         for var, val in valores.items():
             # Para cada valor para cambiar...
@@ -284,6 +292,58 @@ def cambiar_vals_modelo_interno(símismo, valores):
 
                 # Cambiar el valor del diccionario interno para la estación actual.
                 símismo.datos_internos[var][símismo.estación] = val
+        """
+
+    def act_vals_clima(símismo, n_paso, f):
+        """
+
+
+        :param n_paso:
+        :type n_paso: int
+        :param f:
+        :type f: ft.datetime
+
+        """
+
+        # Si avanzamos por más que un año, perderemos la precisión del clima
+        if n_paso > 12:
+            avisar('El paso es superior a 1 año (12 meses). Las predicciones climáticas perderán su precisión.')
+
+        # Solamante hay que cambiar los datos si es el principio de un nuevo año.
+        if símismo.mes == 0 and símismo.estación == 0:
+
+            # La lista de variables climáticos
+            vars_clima = list(símismo.vars_clima)
+            nombres_extrn = [d['nombre_extrn'] for d in símismo.vars_clima.values()]
+
+            # La lista de maneras de combinar los valores diarios
+            combins = [d['combin'] for d in símismo.vars_clima.values()]
+
+            # La fecha inicial
+            f_inic = f
+
+            for e, dur in enumerate(símismo.dur_estaciones):
+                # Para cada estación...
+
+                # La fecha final
+                f_final = f_inic + deltarelativo(months=+dur)
+
+                # Calcular los datos
+                datos = símismo.datos_clima.comb_datos(vars_clima=nombres_extrn, combin=combins,
+                                                       f_inic=f_inic, f_final=f_final)
+
+                # Aplicar los valores de variables calculados
+                for i, var in enumerate(vars_clima):
+                    # Para cada variable en la lista de clima...
+
+                    # El nombre oficial del variable de clima
+                    var_clima = nombres_extrn[i]
+
+                    # Guardar el valor para esta estación
+                    símismo.datos_internos[var][e, ...] = datos[var_clima]
+
+                # Avanzar la fecha
+                f_inic = f_final
 
     def incrementar(símismo, paso):
         """
@@ -314,11 +374,8 @@ def incrementar(símismo, paso):
                 # Para cada variable en el diccionario interno de variables (es decir, todos los variables que
                 # cambian por estación)...
 
-                # Poner el valor del variable al valor de esta estación
-                try:
-                    símismo.variables[var]['val'] = símismo.datos_internos[var][e]
-                except IndexError:
-                    pass
+                # Poner el valor del variable al valor de esta estación. (Guarda el enlace dinámico.)
+                símismo.variables[var]['val'] = símismo.datos_internos[var][e]
 
             # Si es la primera estación del año, también hay que correr una simulación del modelo externo.
             if e == 0:
@@ -410,6 +467,7 @@ def avanzar_modelo(símismo):
     def leer_vals_inic(símismo):
         """
         Esta función lee los valores iniciales del modelo.
+
         :return:
         :rtype:
         """
@@ -521,6 +579,7 @@ class ModeloFlexible(ModeloBF):
     """
 
     """
+
     def __init__(símismo):
         """
         Esta función correrá automáticamente con la inclusión de `super().__init__()` en la función `__init__()` de las

tinamit/Conectado.py

@@ -1,13 +1,13 @@
 import threading
 from warnings import warn as avisar
+import datetime as ft
 
 from tinamit.BF import EnvolturaBF
 from tinamit.MDS import generar_mds
 from tinamit.Modelo import Modelo
 from tinamit.Unidades.Unidades import convertir
 
-
-# from PyMarkSim.مرکسم import مقام as pred_clima
+from taqdir.مقامات import مقام
 
 
 class SuperConectado(Modelo):
@@ -224,10 +224,60 @@ def cambiar_vals_modelo_interno(símismo, valores):
             # Ahora, pedimos a los submodelos de hacer los cambios en los modelos externos, si hay.
             símismo.modelos[nombre_mod].cambiar_vals(valores={var: val})
 
-    def conectar_clima(símismo):
-        pass
+    def _conectar_clima(símismo, n_pasos, clima, fecha_inic, tcr):
+        """
+
+        :param  n_pasos:
+        :type n_pasos: int
+        :param clima:
+        :type clima: مقام
+        :param fecha_inic:
+        :type fecha_inic: ft.date | ft.datetime | str | int
+        :param tcr:
+        :type tcr: str | float
 
-    def simular(símismo, tiempo_final, paso=1, nombre_corrida='Corrida Tinamït'):
+        """
+
+        # Formatear la fecha inicial
+        if isinstance(fecha_inic, ft.date):
+            pass
+        elif isinstance(fecha_inic, ft.datetime):
+            fecha_inic = fecha_inic.date()
+        elif isinstance(fecha_inic, int):
+            año = fecha_inic
+            día = mes = 1
+            fecha_inic = ft.date(year=año, month=mes, day=día)
+        elif isinstance(fecha_inic, str):
+            try:
+                fecha_inic = ft.datetime.strptime(fecha_inic, '%d/%m/%Y')
+            except ValueError:
+                raise ValueError('La fecha inicial debe ser en formato "día/mes/año", por ejemplo "24/12/2017".')
+
+        # Calcular la fecha final
+        n_días = convertir(de=símismo.unidad_tiempo, a='días', val=n_pasos)
+        fecha_final = fecha_inic + ft.timedelta(n_días)
+
+        # Obtener los datos de clima
+        datos = clima.prep_datos(primer_año=fecha_inic.year, último_año=fecha_final.year, rcp=tcr,
+                                 n_rep=1, diario=True, mensual=True, postdict=None, predict=None, regenerar=True)
+
+        símismo.datos_clima = NotImplemented
+
+    def act_vals_clima(símismo, paso, f):
+        """
+
+        :param paso:
+        :type paso:
+        :param f:
+        :type f:
+
+        """
+
+        for nombre, mod in símismo.modelos.items():
+            mod.act_vals_clima(paso=símismo.conv_tiempo[nombre] * paso, f=f)
+
+    def simular(símismo, tiempo_final, paso=1, nombre_corrida='Corrida Tinamït', fecha_inic=None, lugar=None, tcr=None,
+                clima=False):
         """
         Simula el modelo :class:`~tinamit.Conectado.SuperConectado`.
 
@@ -251,11 +301,38 @@ def simular(símismo, tiempo_final, paso=1, nombre_corrida='Corrida Tinamït'):
             raise ValueError('Hay que especificar la conversión de unidades de tiempo con '
                              '.estab_conv_tiempo() antes de correr la simulación.')
 
+        # Calcular el número de pasos necesario
+        n_pasos = int(tiempo_final / paso)
+
+        # Conectar el clima, si necesario
+        if clima:
+            if lugar is None:
+                raise ValueError('Hay que especificar un lugar para incorporar el clima.')
+            else:
+                if fecha_inic is None:
+                    raise ValueError('Hay que especificar la fecha inicial para simulaciones de clima')
+                if tcr is None:
+                    tcr = 8.5
+                símismo._conectar_clima(n_pasos=n_pasos, clima=lugar, fecha_inic=fecha_inic, tcr=tcr)
+
         # Iniciamos el modelo.
         símismo.iniciar_modelo(tiempo_final=tiempo_final, nombre_corrida=nombre_corrida)
 
+        # Si hay fecha inicial, tenemos que guardar cuenta de donde estamos en el calendario
+        if fecha_inic is not None:
+            fecha_act = fecha_inic
+        else:
+            fecha_act = None
+
         # Hasta llegar al tiempo final, incrementamos el modelo.
-        for i in range(int(tiempo_final / paso)):
+        for i in range(n_pasos):
+
+            # Actualizar variables de clima, si necesario
+            if clima:
+                símismo.act_vals_clima(paso=paso, f=fecha_act)
+                fecha_act += ft.timedelta(paso)  # Avanzar la fecha
+
+            # Incrementar el modelo
             símismo.incrementar(paso)
 
         # Después de la simulación, cerramos el modelo.