Tanques y flujos

01 · Punto de partida

El patrón que aparece en todas partes

Agua en un tanque, stock en un depósito, carga en una batería, espera en una cola: todos son niveles que acumulan la diferencia entre entrar y salir. La ecuación madre es dN/dt = q_in(t) − q_out(N), con entradas que el entorno impone y salidas que el nivel decide.

Dominar el tanque es dominar el 80 % de los modelos continuos aplicados: cambia el líquido, no la cuenta.

• ¿Qué entra (q_in) y quién lo decide?
• ¿Qué sale (q_out) y depende de N o es fijo?
• ¿Hay piso (0) y techo (capacidad)?
• ¿La entrada es fija, pulsante o con ritmo?

02 · Definición

¿Qué es un modelo de tanque?

Un nivel con sus dos canillas:

Sin límites es la EDO ideal; con límites es el modelo útil: el piso y el techo son condiciones de contorno físicas.

03 · Anatomía

Fija, pulsante y con ritmo

La entrada manda la forma de la respuesta:

Entrada fija

q constante: el nivel converge a q/k y se queda. Régimen plano.

Entrada pulsante

Escalones (abro/cierro): el nivel persigue cada escalón con retardo 1/k.

Entrada con ritmo

q₀ + A·sin(2πt/Tp): el nivel oscila atenuado y desfasado alrededor de q₀/k.

Límites 0 y C

Piso que recorta vaciados, techo que vierte excedentes: la EDO se pausa en los bordes.

04 · Tanques en el curso

El arquetipo con cinco líquidos

Cada acumulación con entradas y salidas es un tanque:

1. 1
   Agua.

   El original: canilla, desagüe, rebalse. Referencia de todo.

2. 2
   Inventario.

   Compras menos ventas con capacidad de galpón.

3. 3
   Batería.

   Carga menos consumo entre 0 y 100 %.

4. 4
   Cola.

   Llegadas menos atenciones: espera acumulada.

5. 5
   Contaminante.

   Vertido menos degradación k·N en un lago.

05 · Representación en Python

Entradas que dependen de t, salidas de N

En Python, la entrada es función del tiempo y la salida función del nivel. Euler con recorte respeta piso y techo.

import math


def entrada(t, q0=3.0, amp=2.0, periodo=10.0):
    return q0 + amp * math.sin(2 * math.pi * t / periodo)


def paso(nivel, t, dt=0.1, k=0.2, techo=30.0):
    d = entrada(t) - k * nivel
    nuevo = nivel + d * dt
    return max(0.0, min(techo, nuevo))


print(round(entrada(0), 2), round(entrada(2.5), 2))

3,0 en t = 0 y 5,0 en t = 2,5: la canilla respira con período 10.

Simular con ritmo y límites

El bucle integra la EDO no autónoma con recorte físico:

def simular(n0=15.0, t_final=40.0, dt=0.1, k=0.2, techo=30.0):
    n, t = n0, 0.0
    historia = [(t, n)]
    while t < t_final - 1e-9:
        n = paso(n, t, dt, k, techo)
        t += dt
        historia.append((round(t, 1), round(n, 2)))
    return historia


hist = simular()
print(hist[0], "…", hist[-1])

06 · Exploración

Laboratorio: la canilla que respira

Tanque con desagüe k y entrada rítmica q₀ + A·sin(2πt/10) desde N₀ = q₀/k. La teal punteada es la entrada (eje propio); la dorada es el nivel que la sigue atenuado y con retardo. Subí A y observá que el nivel oscila sin desbocarse: el desagüe lo cuida.

La entrada oscila ±2 pero el nivel solo ±3,02 alrededor de 15 con retardo: el tanque filtra el ritmo (pasa-bajos).

Preguntas para explorar

1. Con A = 0, ¿qué dibuja el nivel? ¿Cuál es su valor?
2. Duplicá k con la misma A. ¿La oscilación del nivel crece o se achica?
3. Si A > q₀ (entra negativo a ratos), ¿qué significa y qué hace el piso 0?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: medio que manda

Con q₀ = 4, A = 1 y k = 0,2, ¿alrededor de qué nivel oscila? Comprobalo con el promedio.

print(4 / 0.2)

Ejercicio 2: atenuación

La oscilación del nivel es A/√(k² + ω²) con ω = 2π/10. Calculala con A = 2 y k = 0,2. ¿Cierra con ±3,02?

import math


def oscilacion(a=2.0, k=0.2, periodo=10.0):
    w = 2 * math.pi / periodo
    return a / math.sqrt(k ** 2 + w ** 2)


print(round(oscilacion(), 2))

Ejercicio 3: con piso y techo

Agregá piso 0 y techo 18 al simulador con q₀ = 3, A = 3 y k = 0,2. ¿El techo recorta?

import math


def simular(q0=3.0, amp=3.0, k=0.2, techo=18.0, t_final=40.0, dt=0.1):
    n, t, mx = q0 / k, 0.0, 0.0
    while t < t_final - 1e-9:
        q = q0 + amp * math.sin(2 * math.pi * t / 10)
        n = max(0.0, min(techo, n + (q - k * n) * dt))
        mx = max(mx, n)
        t += dt
    return round(mx, 2)


print(simular())

09 · Síntesis

Ideas para recordar

En el próximo tema generalizaremos la máquina: sistemas dinámicos y su comportamiento global.