Combinación con contexto_redes

pruebas/test_móds/test_cultivo/test_cultivo.py

@@ -24,8 +24,8 @@ def setUpClass(cls):
         cls.mód_cult = Cultivo()
         cls.ins = LotkaVolterra('insecto')
         cls.tomate = Tomate()
-        cls.ins.secome(cls.tomate)
-        cls.red = RedAE([cls.tomate, cls.ins])
+        with RedAE([cls.tomate, cls.ins]) as cls.red:
+            cls.ins.secome(cls.tomate)
 
     def _prueba_parc(símismo, parc):
         res = Modelo(
@@ -35,7 +35,7 @@ def _prueba_parc(símismo, parc):
         npt.assert_equal(res[Cultivo.nombre][RES_BIOMASA].res.values, símismo.biomasa)
         npt.assert_equal(res[Cultivo.nombre][RES_HUMSUELO].res.values, símismo.hum_suelo)
         npt.assert_equal(
-            res[RedAE.nombre][RES_POBS].res.loc[{EJE_ETAPA: símismo.tomate.etapas()}].values, símismo.biomasa
+            res[RedAE.nombre][RES_POBS].res.loc[{EJE_ETAPA: símismo.tomate.etapas}].values, símismo.biomasa
         )
 
     def test_combin(símismo):

pruebas/test_móds/test_cultivo/test_pcse.py

@@ -19,8 +19,8 @@ class PruebaPCSE(unittest.TestCase):
     def test_pcse(símismo):
         gusanito = LotkaVolterra('soy gusano')
         remolacha = RemolachaAzucarera()
-        gusanito.secome(remolacha)
-        red = RedAE([remolacha, gusanito])
+        with RedAE([remolacha, gusanito]) as red:
+            gusanito.secome(remolacha)
 
         modelo = Wofost71_PP
         parc = ParcelasCultivoPCSE(

pruebas/test_móds/test_rae/rcrs/redes.py

@@ -9,6 +9,7 @@
 esfécido = Esfécido('esfécido')
 parasitoide = Parasitoide('parasitoide')
 paras_con_pupa = Parasitoide('parasitoide con pupa', pupa=True)
+hiperparasitoide = Parasitoide('hiperparasitoide')
 
 metam_completa = MetamCompleta('metamórfosis completa')
 metam_comp_sin_huevo = MetamCompleta('metamórfosis completa sin huevo', huevo=False)
@@ -22,17 +23,27 @@
 
 red_1_insecto = RedAE([sencillo])
 
-otro_sencillo.secome(sencillo)
-otro_más.secome(sencillo)
-otro_más.secome(otro_sencillo)
-red_depred = RedAE([sencillo, otro_sencillo, otro_más])
+red_depred_mútliples = RedAE([sencillo, otro_sencillo, otro_más])
+red_depred = RedAE([sencillo, otro_más])
 
-red_depred_sub = RedAE([sencillo, otro_más])
+with red_depred_mútliples:
+    otro_más.secome(otro_sencillo)
+    otro_sencillo.secome(sencillo)
+    with red_depred:
+        otro_más.secome(sencillo)
 
-parasitoide.parasita(metam_completa, etps_entra=['juvenil'], etp_emerg='pupa')
-red_parasitismo = RedAE([metam_completa, parasitoide])
+with RedAE([metam_completa, parasitoide]) as red_parasitismo:
+    parasitoide.parasita(metam_completa)
 
-esfécido.captura(metam_completa, etps_presa='juvenil')
-red_esfécido = RedAE([esfécido, metam_completa])
+with RedAE([esfécido, metam_completa]) as red_esfécido:
+    esfécido.captura(metam_completa)
+
+with RedAE([metam_completa, hiperparasitoide, paras_con_pupa]) as red_hiperparasitismo:
+    paras_con_pupa.parasita(metam_completa)
+    hiperparasitoide.parasita(paras_con_pupa)
+
+with RedAE([parasitoide, metam_completa, metam_incompleta]) as red_paras_generalista:
+    parasitoide.parasita(metam_completa)
+    parasitoide.parasita(metam_incompleta)
 
 exper = Exper('exper', Parcela('parc'))

pruebas/test_móds/test_rae/test_ecs/test_depred.py

@@ -14,17 +14,19 @@ class PruebaDepred(unittest.TestCase):
     def test_depred(símismo):
         presa = LotkaVolterra('Presa')
         depred = LotkaVolterra('Depredador')
-        depred.secome(presa)
-
         depred_2 = LotkaVolterra('Depredador secundario')
-        depred_2.secome(presa)
-        depred_2.secome(depred)
+        red = RedAE([presa, depred, depred_2])
+
+        with red:
+            depred.secome(presa)
+            depred_2.secome(presa)
+            depred_2.secome(depred)
 
         f_inic, f_final = '2000-01-01', '2000-01-10'
         t = Tiempo(f_inic, f_final)
         for ec in EcDepred.cls_ramas:
             with símismo.subTest(ec.nombre):
-                mod = gen_modelo_reqs_clima(ec, exper=exper, módulos=RedAE([presa, depred, depred_2]), t=t)
+                mod = gen_modelo_reqs_clima(ec, exper=exper, módulos=red, t=t)
                 depred.activar_ec(ECS_DEPR, subcateg='Ecuación', ec=ec.nombre)
                 depred_2.activar_ec(ECS_DEPR, subcateg='Ecuación', ec=ec.nombre)
                 mod.simular(str(ec), exper=exper, t=10, depurar=True)

pruebas/test_móds/test_rae/test_red/test_red.py

@@ -1,21 +1,81 @@
 import unittest
 
+from pruebas.test_móds.test_rae.rcrs import redes as r
 from tikon.central import Modelo
-from pruebas.test_móds.test_rae.rcrs import redes
+from tikon.móds.rae.red import RedAE
 
 
 class PruebaRed(unittest.TestCase):
     def test_1_insecto(símismo):
-        res = Modelo(redes.red_1_insecto).simular('1 insecto', exper=redes.exper, t=10, depurar=True)
+        res = Modelo(r.red_1_insecto).simular('1 insecto', exper=r.exper, t=10, depurar=True)
 
-    def test_red_depred(símismo):
-        res = Modelo(redes.red_depred).simular('depred', exper=redes.exper, t=10, depurar=True)
+    def test_depred(símismo):
+        símismo.assertSetEqual(r.red_depred.presas(), set(r.sencillo.etapas))
+        res = Modelo(r.red_depred).simular('depred sub', exper=r.exper, t=10, depurar=True)
 
-    def test_red_depred_sub(símismo):
-        res = Modelo(redes.red_depred_sub).simular('depred sub', exper=redes.exper, t=10, depurar=True)
+    def test_depred_mútliples(símismo):
+        símismo.assertSetEqual(
+            set(r.red_depred_mútliples.presas()), set(r.sencillo.etapas).union(r.otro_sencillo.etapas)
+        )
+        res = Modelo(r.red_depred_mútliples).simular('depred', exper=r.exper, t=10, depurar=True)
 
-    def test_red_parasitismo(símismo):
-        res = Modelo(redes.red_parasitismo).simular('parasitismo', exper=redes.exper, t=10, depurar=True)
+    def test_parasitismo(símismo):
+        res = Modelo(r.red_parasitismo).simular('parasitismo', exper=r.exper, t=10, depurar=True)
 
-    def test_red_esfécido(símismo):
-        res = Modelo(redes.red_esfécido).simular('esfécido', exper=redes.exper, t=10, depurar=True)
+    def test_esfécido(símismo):
+        res = Modelo(r.red_esfécido).simular('esfécido', exper=r.exper, t=10, depurar=True)
+
+    def test_hiperparasitismo(símismo):
+        res = Modelo(r.red_hiperparasitismo).simular('esfécido', exper=r.exper, t=10, depurar=True)
+
+    def test_parasitismo_circular(símismo):
+        with símismo.assertRaises(ValueError):
+            with RedAE():
+                r.parasitoide.parasita(r.metam_completa)
+                r.hiperparasitoide.parasita(r.parasitoide)
+                r.parasitoide.parasita(r.hiperparasitoide)
+
+    def test_parasitoide_generalista(símismo):
+        # Verifica que múltiples transiciones a la misma etapa (de huéspedes al parasitoide adulto) funcionen
+        res = Modelo(r.red_paras_generalista).simular('paras generalista', exper=r.exper, t=10, depurar=True)
+
+    def test_canibalismo(símismo):
+        pass
+
+    def test_depredador_y_parasitoide(símismo):
+        pass
+
+    def test_depredador_e_hyperparasitoide(símismo):
+        pass
+
+    def test_depredador_de_parasitoide(símismo):
+        pass
+
+    def test_depredador_de_hyperparasitoide(símismo):
+        pass
+
+
+class PruebaParasitismo(unittest.TestCase):
+    def test_entra_auto_mútiples_juveniles(símismo):
+        pass
+
+    def test_entra_auto_sin_juvenil(símismo):
+        pass
+
+    def test_entra_auto_juvenil_único(símismo):
+        pass
+
+    def test_entra_auto_huevo(símismo):
+        pass
+
+    def test_emerg_auto(símismo):
+        pass
+
+    def test_emerg_auto_entra_final(símismo):
+        pass
+
+    def test_emerge_antes_entra(símismo):
+        pass
+
+    def test_sin_espec(símismo):
+        pass

tikon/central/coso.py

@@ -61,3 +61,21 @@ def _ecs_de_json(símismo, calibs):
 
     def __str__(símismo):
         return símismo.nombre
+
+    def __eq__(símismo, otro):
+        return isinstance(otro, símismo.__class__) and símismo.nombre == otro.nombre
+
+    def __hash__(símismo):
+        return hash(símismo.nombre)
+
+
+class SumaCosos(object):
+    def __init__(símismo, cosos):
+        símismo.cosos = cosos
+
+    def __add__(símismo, otro):
+        return SumaCosos(*list(otro), *símismo.cosos)
+
+    def __iter__(símismo):
+        for coso in símismo.cosos:
+            yield coso

tikon/central/paráms_exper.py

@@ -36,7 +36,7 @@ def __init__(símismo, nombre, exper, sim, datos, n_reps):
         líms = proc_líms(sim.líms)
         # para hacer: estandardizar
         if símismo.datos.obs:
-            ref = min(líms[1], np.nanmax([o_.datos.values.max() for o_ in símismo.datos.obs]))
+            ref = min(líms[1], np.nanmax([np.nanmax(o_.datos.values) for o_ in símismo.datos.obs]))
             if líms == (0, np.inf):
                 apriori = APrioriDist(expon(0, ref))
             else:

tikon/central/res.py

@@ -125,8 +125,11 @@ def procesar_calib(símismo, proc):
 
             for índs in símismo.iter_índs(obs.datos, excluir=EJE_TIEMPO):
                 obs_índs = obs_corresp.loc[índs]
-
-                l_proc.append(proc.calc(obs_índs, res_corresp.loc[índs]))
+                ejes_combin = [ll for ll in índs if isinstance(índs[ll], tuple)]
+                res_índs = res_corresp.loc[
+                    {ll: list(v) if ll in ejes_combin else v for ll, v in índs.items()}
+                ].sum(ejes_combin)
+                l_proc.append(proc.calc(obs_índs, res_índs))
                 pesos.append(proc.pesos(obs_índs))
         if l_proc:
             return proc.combin(np.array(l_proc), pesos=pesos), proc.combin_pesos(pesos)

tikon/central/simul.py

@@ -41,8 +41,11 @@ def validar(símismo, proc):
         return Valid({s: símismo[s].validar(proc=proc) for s in símismo}, proc=proc)
 
     def procesar_calib(símismo, proc):
-        vals, pesos = np.array(list(zip(*[símismo[s].procesar_calib(proc) for s in símismo])))
-        return proc.combin(vals, pesos=pesos), proc.combin_pesos(pesos)
+        evl = list(zip(*[símismo[s].procesar_calib(proc) for s in símismo]))
+        if evl:
+            vals, pesos = np.array(evl)
+            return proc.combin(vals, pesos=pesos), proc.combin_pesos(pesos)
+        return 0, 0
 
     def graficar(símismo, directorio, argsll=None):
         for s in símismo:

tikon/datos/datos.py

@@ -11,7 +11,7 @@ def _índices(símismo, dic):
         if isinstance(dic, Datos):
             dic = dic.coords
         return {
-            dm: [símismo.datos.coords[dm].index(c) for c in (crds if isinstance(crds, list) else [crds])]
+            dm: [símismo.datos.coords[dm].index(c) for c in (crds if isinstance(crds, (list, set)) else [crds])]
             for dm, crds in dic.items()
         }
 

tikon/datos/obs.py

@@ -37,6 +37,9 @@ def de_cuadro(cls, datos_pd, corresp, eje_principal, parc=None, tiempo=None, coo
         if isinstance(datos_pd, str):
             datos_pd = pd.read_csv(datos_pd, encoding='utf8')
         corresp = corresp or {}
+        for ll, v in corresp.items():
+            if isinstance(v, list):
+                corresp[ll] = tuple(v)
         coords = {
             EJE_PARC: parc or EJE_PARC,
             EJE_TIEMPO: tiempo or EJE_TIEMPO,
@@ -46,9 +49,10 @@ def de_cuadro(cls, datos_pd, corresp, eje_principal, parc=None, tiempo=None, coo
         coords_xr = coords.copy()
         for dim, crd in coords.items():
             if isinstance(dim, str) and crd in datos_pd.columns:
-                coords_xr[dim] = datos_pd[crd]
+                coords_xr[dim] = datos_pd[crd].unique()
             else:
                 coords_xr[dim] = [crd]
+
         coords_xr[eje_principal] = list(corresp.values())
         datos = xr.DataArray(np.nan, coords=coords_xr, dims=list(coords_xr))
 
@@ -60,7 +64,7 @@ def de_cuadro(cls, datos_pd, corresp, eje_principal, parc=None, tiempo=None, coo
             }
             vals = d[[x for x in list(d.axes[0]) if x in corresp]]
             datos.loc[índs] = vals * factor
-
+        datos.coords[EJE_PARC] = [str(prc) for prc in datos.coords[EJE_PARC].values]
         return cls(datos)
 
     def __contains__(símismo, itema):

tikon/datos/proc.py

@@ -12,7 +12,12 @@ def n_existen(x):
 
 # Funciones criterios
 def ens(o, s):
-    return of.nashsutcliffe(o.values, s.median(dim=(EJE_PARÁMS, EJE_ESTOC)).values)
+    ev = of.nashsutcliffe(o.values, s.median(dim=(EJE_PARÁMS, EJE_ESTOC)).values)
+    if np.isnan(ev):
+        return 1
+    elif np.isinf(ev):
+        return -1e6
+    return ev
 
 
 def rcep(o, s):

tikon/móds/rae/manejo.py

@@ -23,12 +23,12 @@ def __init__(símismo, etapas, prueba, func=Datos.suma, espera=14):
 
 class AcciónPob(Acción):
     def __init__(símismo, etapa):
-        símismo.etapa = etapa
+        símismo.etapa = [etapa] if isinstance(etapa, Etapa) else etapa
 
     def _proc_pobs(símismo, pobs):
         if isinstance(pobs, Datos):
-            return pobs.expandir_dims(coords={EJE_ETAPA: [símismo.etapa]})
-        return Datos(pobs.item(), coords={EJE_ETAPA: [símismo.etapa]}, dims=[EJE_ETAPA])
+            return pobs.expandir_dims(coords={EJE_ETAPA: símismo.etapa})
+        return Datos(pobs.item(), coords={EJE_ETAPA: símismo.etapa}, dims=[EJE_ETAPA])
 
     def __call__(símismo, sim, donde):
         raise NotImplementedError

tikon/móds/rae/orgs/insectos/ins.py

@@ -49,7 +49,7 @@ def resolver_etapas(símismo, etapas):
         if etapas is not None and JUVENIL in etapas:
             etapas.remove(JUVENIL)
 
-            for etp in símismo._etapas:
+            for etp in símismo.etapas:
                 if etp.nombre.startswith(JUVENIL):
                     etapas.append(etp)
 

tikon/móds/rae/orgs/insectos/paras.py

@@ -56,7 +56,7 @@ def __init__(símismo, nombre, pupa=False):
             nombre=nombre, huevo=False, njuvenil=1, pupa=pupa, adulto=True, tipo_ecs=tipo_ec
         )
 
-    def parasita(símismo, huésped, etps_entra, etp_emerg, etp_símismo='adulto', etp_recip=None):
+    def parasita(símismo, huésped, etps_entra=None, etp_emerg=None, etp_símismo='adulto', etp_recip=None):
         """
         Indica la relación de parasitismo.
 
@@ -78,6 +78,19 @@ def parasita(símismo, huésped, etps_entra, etp_emerg, etp_símismo='adulto', e
 
         if etp_recip is None:
             etp_recip = 'pupa' if símismo.pupa else 'adulto'
+
+        if etps_entra is None:
+            try:
+                etps_entra = huésped['juvenil']
+            except KeyError:
+                etps_entra = huésped.etapas[0]
+
+        if etp_emerg is None:
+            siguiente = (etps_entra if isinstance(etps_entra, Etapa) else etps_entra[-1]).siguiente()
+            etp_emerg = siguiente or huésped.etapas[-1]
+
+        # if etp_emerg.index():
+        #     raise ValueError('')
         super().parasita(
             huésped=huésped, etp_símismo=etp_símismo, etps_entra=etps_entra, etp_emerg=etp_emerg, etp_recip=etp_recip
         )
@@ -135,17 +148,5 @@ def captura(símismo, presa, etps_presa=None):
         etps_presa: Etapa or str or list
             La(s) etapa(s) de la presa que pueden ser víctimas.
         """
+        etps_presa = etps_presa or presa['juvenil']
         símismo.secome(presa=presa, etps_presa=etps_presa, etps_símismo='adulto')
-
-    def nocaptura(símismo, presa, etps_presa=None):
-        """
-        Borra una relación entre un Esfécido y una presas.
-
-        Parameters
-        ----------
-        presa: Insecto
-            La presa.
-        etps_presa: Etapa or str or list
-            La(s) etapa(s) de la presa que ya no pueden ser víctimas.
-        """
-        símismo.nosecome(presa=presa, etps_presa=etps_presa, etps_símismo='adulto')