# Laboratorio cell — del átomo al cromosoma

Simuladores del ADN construidos desde la física atómica, por fases. Cada visor se
conserva tal como cerró su fase. El punto de entrada es **`index.html`**.

## Cómo abrirlo

**Lo fácil (recomendado): doble clic en `abrir_laboratorio.bat`.**
Arranca un servidor local y abre `http://localhost:8321/index.html` en el navegador.
Para apagarlo, cierra la ventana negra (o Ctrl+C).

Equivalente a mano, desde PowerShell en esta carpeta:

```powershell
python -m http.server 8321      # y abrir http://localhost:8321/index.html
```

No usamos uvicorn ni nada que haya que instalar: `http.server` viene con Python y
solo sirve ficheros estáticos, que es todo lo que necesitamos.

**Vías en directo**: `abrir_laboratorio.bat` arranca además, cada uno en su propia ventana,
`f9_servidor.py` (F9a, puerto 8322: OpenMM en la GPU sirviendo fotogramas a `directo.html`)
y, cuando exista, `f10_enlace.py` (F10, puerto 8323: la curva de Morse en vivo). Cerrar esa
ventana apaga solo esa simulación. Para levantar el laboratorio sin ellas:
`abrir_laboratorio.bat sindirecto`. Análisis y subfases pendientes en `plan_F9_directo.md`
y `plan_F10_enlace.md`.

**¿Y con doble clic directo en cada .html (file://)?** Funciona todo — los visores
llevan sus datos embebidos — con una excepción: `trayectoria.html` no puede cargar
`trayectorias/f5_visor.bin` automáticamente (los navegadores bloquean `fetch` sobre
`file://`); te pedirá elegir el fichero a mano. Con el servidor, carga sola.

## Qué hay

| Fichero | Fase | Qué es |
|---|---|---|
| `index.html` | — | el portal: tarjetas con captura, descripción y arranques con parámetros |
| `visor.html` | F1 | el cristal 1BNA (rayos X, 1981), sin física: la ventana |
| `sandbox.html` | F2 | caja de agua con motor MD propio; los puentes de H emergen |
| `bases.html` | F3 | adenina + timina (cuerpos rígidos); emparejamiento y competencia con agua |
| `campos.html` + `campo.js` | F4+F6 | F3 más la capa de campo: isosuperficies y corte (F4) y modo medio con tecla J — ε=80 + apantallamiento de Debye por sal, ajustable con 7/8 (F6; el PB completo tipo APBS queda como extensión pro) |
| `trayectoria.html` + `f5_simular.py` | F5 | simulación rigurosa OpenMM del 1BNA y su reproductor |
| `soluciones.html` + `campo7.js` | F7a–e | el motor de F2 con iones: `?exp=presion` (manómetro de pared), `sal` (cristalito de NaCl), `osmosis` (pared iónica de Luo–Roux + pistón), `campo` (electroforesis, condensador/circuito), `debye` (carga fija y perfil radial); `campo7.js` es la capa de campos de F4/F6 con el término −E·x |
| `Del_atomo_al_cromosoma.html` | F0/0b | el análisis completo (también en los dos `.md`) |
| `cuaderno.html` | — | el cuaderno de preguntas en página navegable (`cuaderno-de-preguntas.md` es la fuente) |
| `plan_F7_soluciones.md` | F7a–e | **plan** (aún sin visor) de los experimentos de soluciones en vivo: presión, sal disolviéndose, ósmosis con paredes virtuales, campo eléctrico y apantallamiento de Debye, más su vía de rigor OpenMM y los experimentos de cocina seguros |
| `f9_servidor.py` + `directo.html` | F9a–c | **la vía en directo**: OpenMM corriendo en la GPU y sirviendo fotogramas por HTTP (127.0.0.1:8322) al visor, que devuelve las teclas. Los tres experimentos comparten servidor y se eligen desde el visor: `directo.html?exp=electrolito` (campo conmutable, movilidad y conductividad) · `?exp=poro` (membrana con un agujero y voltaje: cruces, filtro) · `?exp=bomba` (dos compuertas y un sitio alternante: el gradiente sube). Cambiar de uno a otro cuesta unos segundos |
| `bomba.html` + `data/3WGU.pdb`, `data/2ZXE.pdb` | F9d | la bomba Na⁺/K⁺ **medida**: E1 con 3 Na⁺ y E2 con 2 K⁺, con la jaula de oxígenos de cada sitio de unión calculada del propio dato |
| `musculo.html` | F9e | el músculo a su escala (Hodgkin-Huxley + calcio + puentes cruzados): sacudida, tétanos, fatiga y qué pasa al bloquear la bomba. JavaScript puro, sin servidor |
| `plan_F9_directo.md` | F9a–e | el plan y el análisis de la vía en directo (F9a–F9e ✓) |
| `enlace.html` | F10 | romper un enlace tirando con una pinza, con tres modelos sobre la misma curva: muelle (no cede nunca), Morse, y el **cálculo cuántico exacto del H₂⁺** (LCAO, sin parámetros ajustados) con su nube electrónica y su orbital antienlazante |
| `plan_F10_enlace.md` | F10 | el plan y el análisis; F10 entregada por la vía cuántica propia, la de potenciales ML externos sigue pendiente |
| `onda.html` + `f11_onda.py` + `data/f11_onda.json` | F11a | **la cuantización emerge**: la ecuación de Schrödinger integrada por tiro (Numerov) para una energía cualquiera, y la onda que se dispara salvo en los niveles; catálogo de niveles con nodos y fórmula; la ecuación con tiempo (Crank–Nicolson) con paquetes que se ensanchan, renacen y atraviesan barreras. Cinco pozos: caja, muelle, pozo doble, Coulomb 1D, barrera. El script calcula los mismos niveles con qmsolve y SciPy y los deja en el JSON para el visor |
| `plan_F11_atomo.md` | F11a–h | **plan** del átomo por dentro (F11a ✓): la cuantización emergiendo, el hidrógeno exacto, la radiación, el espín y Stern–Gerlach, por qué Pauli (y de dónde sale el muro de F2), la tabla periódica por Hartree–Fock, el núcleo y la radiactividad como túnel, y un protón solo. Con las librerías cuánticas verificadas en esta máquina: `pip install --user qutip qmsolve sympy pyqint` |
| `capturas/` | — | evidencia de cada fase |
| `data/` | — | estructuras de partida (1BNA del PDB, bases de PubChem) |

## Generar trayectorias para F5

```powershell
python -m pip install --user openmm numpy   # una vez
python f5_simular.py --test                 # prueba: 200 ps (~6 min en GPU)
python f5_simular.py --ns 100               # la de verdad (~2 días en la GTX 1650)
python f5_simular.py --resume --ns 100      # retomar donde quedó (las veces que haga falta)
python f5_simular.py --camara vibra --stride_ps 0.004 --ps 4
                                            # cámara de alta velocidad: 4 ps a 4 fs/foto
                                            # (ver con trayectoria.html?traj=f5_cam_vibra.bin)
```

**Se puede interrumpir cuando sea** (Ctrl+C, apagar el PC…): el checkpoint se guarda
tras cada fotograma (~1,5 min de GPU en riesgo como mucho) y `--resume` continúa
exactamente donde quedó. Escribe en `trayectorias/` (excluida del git: regenerable y
pesada — si aprecias las horas de GPU, haz copia de esa carpeta). Los fotogramas son
ficheros: una vez generados se reproducen para siempre, a la velocidad que quieras.
El reproductor tiene la tecla **U** para recargar mientras la simulación sigue corriendo.

## Panel de lanzamiento F5 (solo uso local) y cómo publicar el sitio

La tarjeta F5 del índice tiene un botón **«⚙ lanzar y gestionar»** que abre un modal
con los comandos listos para copiar (prueba, 100 ns, reanudar, cámara de alta
velocidad con calculadora de tamaño) y los enlaces a las trayectorias guardadas
(con recientes recordados en el navegador). Un navegador no puede ejecutar
PowerShell: los «lanzadores» copian el comando y tú lo pegas en tu terminal.

Todo ese panel vive **aparte a propósito**, en `lab-modal.js` — `index.html` solo
lo carga con una línea marcada con comentario. **Para publicar el sitio en
estático** (S3 + CloudFront + dominio, por ejemplo): borra esa línea y el fichero
`lab-modal.js`, sube el resto tal cual, y los usuarios solo verán lo generado.
(Si publicas, recuerda que `trayectorias/` no está en git: sube el `.bin` que
quieras que la gente pueda reproducir.)

## Actualizar el cuaderno HTML

`cuaderno-de-preguntas.md` es la fuente de verdad. Tras añadir entradas:

```powershell
powershell -ExecutionPolicy Bypass -File actualizar_cuaderno.ps1
```

re-inyecta el `.md` dentro de `cuaderno.html` (que lo renderiza en el navegador).