Modelos híbridos

01 · Punto de partida

La EDO anda, el evento interrumpe

La batería se descarga fluida y al llegar al 20 % salta la recarga; el tanque pierde continuo y cada lunes llega el camión; el termostato corta al llegar a 22 °C. Entre eventos manda la EDO; en el evento manda la regla discreta (sumar, recortar, conmutar).

Lo híbrido es el pan de cada día aplicado: ni todo flujo ni todo salto, cada parte con su naturaleza.

• ¿Qué fluye entre eventos (EDO)?
• ¿Qué dispara el evento (fecha, umbral, condición)?
• ¿Qué cambia el evento (salto, reseteo, modo)?
• ¿Cuántos eventos hay y cuánto cuestan?

02 · Definición

¿Qué es un modelo híbrido?

Dos motores con un árbitro:

El simulador híbrido integra la EDO y vigila el disparo en cada paso: si cruza, aplica el salto y sigue.

03 · Anatomía

Tiempo, umbral y salto

Todo híbrido se arma igual:

Evento por tiempo

Fecha fija: cada ΔT, cada lunes 8 h. Fácil de programar, ciego al estado.

Evento por umbral

Condición: N < mínimo, T > máximo. Vigilar cada paso con interpolación del cruce.

Salto o reseteo

N += Q, N = C, modo on/off: el estado cambia discontinuo, el tiempo no.

Modo

Encendido/apagado, cargando/usando: la EDO cambia según el modo (dos f alternadas).

04 · Híbridos del curso

El mismo interruptor, cinco aparatos

Cada control on/off es híbrido:

1. 1
   Inventario.

   Venta fluida + camión semanal: sierra con techo.

2. 2
   Batería.

   Descarga + recarga al 20 %: diente controlado.

3. 3
   Termostato.

   Enfría/corta entre 19 y 21: ciclo límite.

4. 4
   Fármaco.

   Elimina −λM + dosis cada 8 h: meseta terapéutica.

5. 5
   Riego.

   Humedad que cae + lluvia o riego al umbral: verde intermitente.

05 · Representación en Python

Integrar, vigilar, saltar

En Python, el híbrido es un bucle con vigilante: integra el flujo y chequea el disparo en cada nodo.

def simular_hibrido(n0=100.0, k=0.05, umbral=20.0, carga=100.0, t_final=60.0, dt=0.1):
    n, t, eventos = n0, 0.0, []
    historia = [(t, n)]
    while t < t_final - 1e-9:
        n = n + (-k * n) * min(dt, t_final - t)
        t += min(dt, t_final - t)
        if n <= umbral:
            n, eventos = carga, eventos + [round(t, 1)]
        historia.append((round(t, 1), round(n, 1)))
    return historia, eventos


hist, ev = simular_hibrido()
print("eventos:", ev[:5], "… total:", len(ev))

Recargas al cruzar 20: el flujo cae exponencial y el evento lo devuelve a 100.

Contar eventos y mínimos

El híbrido se evalúa por sus eventos, no solo por la curva:

hist, ev = simular_hibrido(umbral=30.0)
print("recargas:", len(ev), "mínimo:", min(n for _, n in hist))

06 · Exploración

Laboratorio: la batería que se rescata sola

Batería que se descarga con k y al cruzar tu umbral salta a 100 (puntos blancos). Subí el umbral y observá que las recargas se juntan; bajá k y observá que se espacian. El mínimo nunca baja del umbral: el evento cuida.

Cada diente es descarga exponencial + salto vertical: la firma del híbrido por umbral. El período sale de ln(100/umbral)/k.

Preguntas para explorar

1. Con umbral 50, ¿las recargas se juntan o se separan? ¿El mínimo sube?
2. Duplicá k con el mismo umbral. ¿El período se duplica o se parte?
3. Si el umbral fuera 100 (lleno), ¿qué haría el simulador?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: período a mano

De 100 a 20 con k = 0,05, ¿cuánto tarda la descarga? Verificá con ln(100/20)/k.

import math


print(round(math.log(100 / 20) / 0.05, 2))

Ejercicio 2: umbral que junta eventos

Compará recargas en T = 60 con umbral 20 y 50 (k = 0,05). ¿Cuántas más hay?

print(simular_hibrido(umbral=20.0)[1])
print(simular_hibrido(umbral=50.0)[1])

Ejercicio 3: evento por tiempo

Agregá un camión Q = 30 cada 14 días sobre descarga k = 0,05. ¿El mínimo aguanta sobre 20?

def con_camion(q=30.0, cada=14.0, k=0.05, t_final=60.0, dt=0.1):
    n, t, prox, mn = 100.0, 0.0, cada, 100.0
    while t < t_final - 1e-9:
        h = min(dt, t_final - t)
        n, t = n + (-k * n) * h, t + h
        if t >= prox - 1e-9:
            n, prox = n + q, prox + cada
        mn = min(mn, n)
    return round(mn, 1)


print(con_camion())

09 · Síntesis

Ideas para recordar

En el próximo tema calibraremos: ajustar tasas a los datos reales.