# Dinámica molecular GROMACS

> **Simulaciones de dinámica molecular aceleradas por GPU — desde el plegamiento de proteínas hasta el descubrimiento de fármacos**

GROMACS (GROningen MAchine for Chemical Simulations) es el paquete de simulación de dinámica molecular más utilizado en el mundo. Originalmente desarrollado en la Universidad de Groningen, ahora es mantenido por una comunidad global y es la herramienta principal de los laboratorios de química computacional y biología estructural en todo el mundo.

Con aceleración por GPU, GROMACS puede simular sistemas de millones de átomos a velocidades que tomarían semanas en hardware solo con CPU. Los alquileres asequibles de GPU de Clore.ai hacen que las simulaciones MD a gran escala sean accesibles para investigadores individuales y pequeños laboratorios.

***

## ¿Qué puedes simular?

* **Plegamiento y dinámica de proteínas** — observar cambios conformacionales en nanosegundos a microsegundos
* **Unión fármaco-proteína** — calcular energías libres de unión para el descubrimiento de fármacos
* **Simulaciones de membranas** — bicapas lipídicas, proteínas de membrana, transporte de iones
* **Interacciones proteína-proteína** — estudiar la formación de complejos y la dinámica de interfaces
* **Ciencia de materiales** — polímeros, nanopartículas, modelos de agua
* **Cálculos de energía libre** — transformaciones alquímicas, PME

***

## Prerrequisitos

* Cuenta en Clore.ai con alquiler de GPU
* Conocimientos básicos de la línea de comandos de Linux
* Archivos del sistema molecular (topología + coordenadas), o use sistemas de ejemplo
* Opcional: GROMACS localmente para visualización (VMD, Pymol)

***

## ¿Por qué usar GROMACS acelerado por GPU?

GROMACS con descarga a GPU proporciona aumentos dramáticos de velocidad:

| Tamaño del sistema | Solo CPU (ns/día) | A100 única (ns/día) | Aceleración |
| ------------------ | ----------------- | ------------------- | ----------- |
| 25K átomos         | \~50              | \~800               | \~16x       |
| 100K átomos        | \~15              | \~400               | \~27x       |
| 500K átomos        | \~3               | \~150               | \~50x       |
| 1M átomos          | \~1               | \~80                | \~80x       |

{% hint style="success" %}
**La aceleración por GPU es más beneficiosa para sistemas grandes (>100K átomos).** Para sistemas de prueba pequeños, el rendimiento de la CPU puede ser comparable debido a la sobrecarga de transferencia de datos.
{% endhint %}

***

## Paso 1 — Alquila una GPU en Clore.ai

1. Ve a [clore.ai](https://clore.ai) → **Marketplace**
2. Filtrar por GPU: **A100, RTX 4090 o RTX 3090** recomendado
3. Para sistemas grandes (>500K átomos): elija A100 de 40GB u 80GB
4. Para simulaciones estándar: RTX 4090 o RTX 3090 ofrecen una excelente relación calidad-precio

**Especificaciones recomendadas:**

* GPU: A100 40GB o RTX 4090
* CPU: 16+ núcleos (GROMACS usa múltiples núcleos para interacciones no enlazadas)
* RAM: 32GB+
* Disco: 50GB+ (las trayectorias pueden ser grandes)

***

## Paso 2 — Desplegar el contenedor de GROMACS

Use la imagen oficial HPC GROMACS de NVIDIA — está optimizada para GPUs NVIDIA con soporte CUDA:

**Imagen Docker:**

```
nvcr.io/hpc/gromacs:2023.2
```

**Puertos expuestos:**

```
22
```

**Variables de entorno:**

```
NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility
GMX_GPU_DD_COMMS=true
GMX_GPU_PME_PP_COMMS=true
GMX_FORCE_UPDATE_DEFAULT_GPU=true
```

{% hint style="info" %}
**Variables de entorno de NVIDIA para GROMACS:**

* `GMX_GPU_DD_COMMS=true` — habilita comunicaciones de descomposición de dominio basadas en GPU
* `GMX_GPU_PME_PP_COMMS=true` — habilita comunicaciones PME-PP basadas en GPU
* `GMX_FORCE_UPDATE_DEFAULT_GPU=true` — fuerza la actualización de coordenadas en GPU (aceleración significativa)
  {% endhint %}

***

## Paso 3 — Conectar y verificar

```bash
ssh root@<ip-del-servidor> -p <puerto-ssh>

# Comprobar la versión de GROMACS
gmx --version

# Comprobar la disponibilidad de GPU
nvidia-smi

# Verificar que GROMACS puede ver la GPU
gmx mdrun -h 2>&1 | grep -i gpu
```

La salida esperada de `gmx --version` debería mostrar:

```
Versión de GROMACS: 2023.2
Versión de CUDA: 11.x o 12.x
Soporte GPU: CUDA
```

***

## Paso 4 — Preparar su sistema

### Usando un sistema de ejemplo (lisozima en agua)

Este es el sistema clásico del tutorial de GROMACS — perfecto para probar su configuración:

```bash
# Crear directorio de trabajo
mkdir -p /workspace/lysozyme && cd /workspace/lysozyme

# Descargar la estructura PDB de la lisozima
wget https://files.rcsb.org/download/1AKI.pdb -O 1AKI.pdb

# Eliminar moléculas de agua de la estructura cristalina
grep -v HOH 1AKI.pdb > 1AKI_clean.pdb

# Generar la topología usando el campo de fuerza AMBER99SB
gmx pdb2gmx \
    -f 1AKI_clean.pdb \
    -o processed.gro \
    -water spce \
    -ff amber99sb-ildn
```

Cuando se le solicite la selección del campo de fuerza, elija `amber99sb-ildn` (opción 6 típicamente).

***

## Paso 5 — Construir la caja de simulación

```bash
# Definir la caja de simulación (dodecaedro, 1.0 nm desde la proteína)
gmx editconf \
    -f processed.gro \
    -o boxed.gro \
    -c \
    -d 1.0 \
    -bt dodecahedron

# Solvatar la caja con agua
gmx solvate \
    -cp boxed.gro \
    -cs spc216.gro \
    -o solvated.gro \
    -p topol.top

# Añadir iones para neutralizar la carga
# Primero crear el archivo tpr para la adición de iones
gmx grompp \
    -f /usr/local/gromacs/share/gromacs/top/em.mdp \
    -c solvated.gro \
    -p topol.top \
    -o ions.tpr

# Añadir iones Na+ y Cl- (0.15M NaCl)
gmx genion \
    -s ions.tpr \
    -o ionized.gro \
    -p topol.top \
    -pname NA \
    -nname CL \
    -neutral \
    -conc 0.15
# Seleccione el grupo 13 (SOL) cuando se le solicite
```

***

## Paso 6 — Minimización de energía

```bash
# Crear el archivo MDP de minimización de energía
cat > em.mdp << 'EOF'
; Parámetros de minimización de energía
integrator      = steep         ; Minimización por descenso más pronunciado
emtol           = 1000.0        ; Detener cuando la fuerza máxima < 1000 kJ/mol/nm
emstep          = 0.01          ; Tamaño de paso inicial
nsteps          = 50000         ; Máximo de pasos de minimización
nstlist         = 1
cutoff-scheme   = Verlet
ns_type         = grid
coulombtype     = PME
rcoulomb        = 1.0
rvdw            = 1.0
pbc             = xyz
EOF

# Preparar TPR para la minimización de energía
gmx grompp \
    -f em.mdp \
    -c ionized.gro \
    -p topol.top \
    -o em.tpr

# Ejecutar minimización de energía en GPU
gmx mdrun \
    -v \
    -deffnm em \
    -gpu_id 0 \
    -ntmpi 1 \
    -ntomp 8

# Comprobar que la energía convergió
gmx energy -f em.edr -o em_potential.xvg
# Seleccione 10 (Potential) luego 0 para salir
```

***

## Paso 7 — Equilibración NVT (Temperatura)

```bash
cat > nvt.mdp << 'EOF'
; Equilibración NVT
define              = -DPOSRES      ; Restricciones de posición
integrator          = md            ; Integrador leap-frog
nsteps              = 50000         ; 100 ps (paso de 2 fs)
dt                  = 0.002         ; Paso de 2 fs
nstxout             = 500
nstvout             = 500
nstenergy           = 500
nstlog              = 500
continuation        = no
constraint_algorithm = lincs
constraints         = h-bonds
lincs_iter          = 1
lincs_order         = 4
cutoff-scheme       = Verlet
ns_type             = grid
nstlist             = 10
rcoulomb            = 1.0
rvdw                = 1.0
DispCorr            = EnerPres
coulombtype         = PME
pme_order           = 4
fourierspacing      = 0.16
tcoupl              = V-rescale
tc-grps             = Protein Non-Protein
tau_t               = 0.1 0.1
ref_t               = 300 300
pcoupl              = no
pbc                 = xyz
EOF

gmx grompp \
    -f nvt.mdp \
    -c em.gro \
    -r em.gro \
    -p topol.top \
    -o nvt.tpr

gmx mdrun \
    -deffnm nvt \
    -gpu_id 0 \
    -ntmpi 1 \
    -ntomp 8 \
    -nb gpu \
    -bonded gpu \
    -pme gpu \
    -update gpu
```

***

## Paso 8 — Equilibración NPT (Presión)

```bash
cat > npt.mdp << 'EOF'
; Equilibración NPT
define              = -DPOSRES
integrator          = md
nsteps              = 50000
dt                  = 0.002
nstxout             = 500
nstvout             = 500
nstenergy           = 500
nstlog              = 500
continuation        = yes
constraint_algorithm = lincs
constraints         = h-bonds
cutoff-scheme       = Verlet
ns_type             = grid
nstlist             = 10
rcoulomb            = 1.0
rvdw                = 1.0
DispCorr            = EnerPres
coulombtype         = PME
tcoupl              = V-rescale
tc-grps             = Protein Non-Protein
tau_t               = 0.1 0.1
ref_t               = 300 300
pcoupl              = Parrinello-Rahman
pcoupltype          = isotropic
tau_p               = 2.0
ref_p               = 1.0
compressibility     = 4.5e-5
refcoord_scaling    = com
pbc                 = xyz
EOF

gmx grompp \
    -f npt.mdp \
    -c nvt.gro \
    -r nvt.gro \
    -t nvt.cpt \
    -p topol.top \
    -o npt.tpr

gmx mdrun \
    -deffnm npt \
    -gpu_id 0 \
    -ntmpi 1 \
    -ntomp 8 \
    -nb gpu \
    -bonded gpu \
    -pme gpu \
    -update gpu
```

***

## Paso 9 — Ejecución de MD de producción

```bash
cat > md.mdp << 'EOF'
; Ejecución de MD de producción
integrator          = md
nsteps              = 5000000      ; 10 ns (paso de 2 fs)
dt                  = 0.002
nstxout-compressed  = 5000        ; Guardar coordenadas cada 10 ps
nstenergy           = 5000
nstlog              = 5000
continuation        = yes
constraint_algorithm = lincs
constraints         = h-bonds
cutoff-scheme       = Verlet
ns_type             = grid
nstlist             = 10
rcoulomb            = 1.0
rvdw                = 1.0
DispCorr            = EnerPres
coulombtype         = PME
tcoupl              = V-rescale
tc-grps             = Protein Non-Protein
tau_t               = 0.1 0.1
ref_t               = 300 300
pcoupl              = Parrinello-Rahman
pcoupltype          = isotropic
tau_p               = 2.0
ref_p               = 1.0
compressibility     = 4.5e-5
pbc                 = xyz
EOF

gmx grompp \
    -f md.mdp \
    -c npt.gro \
    -t npt.cpt \
    -p topol.top \
    -o md.tpr

# Ejecución de producción con descarga completa a GPU
gmx mdrun \
    -deffnm md \
    -gpu_id 0 \
    -ntmpi 1 \
    -ntomp 16 \
    -nb gpu \
    -bonded gpu \
    -pme gpu \
    -update gpu \
    -v
```

{% hint style="info" %}
**Monitorear el progreso en tiempo real:**

```bash
tail -f md.log | grep -E "(ns/day|Step|Time)"
```

{% endhint %}

***

## Paso 10 — Análisis

### Análisis básico de la trayectoria

```bash
# RMSD (estabilidad de la columna vertebral a lo largo del tiempo)
gmx rms \
    -s md.tpr \
    -f md.xtc \
    -o rmsd.xvg \
    -tu ns
# Seleccione 4 (Backbone) tanto para el grupo de referencia como para el ajustado

# RMSF (flexibilidad por residuo)
gmx rmsf \
    -s md.tpr \
    -f md.xtc \
    -o rmsf.xvg \
    -res
# Seleccione 4 (Backbone)

# Radio de giro (compacidad)
gmx gyrate \
    -s md.tpr \
    -f md.xtc \
    -o gyrate.xvg
# Seleccione 1 (Protein)

# Puentes de hidrógeno
gmx hbond \
    -s md.tpr \
    -f md.xtc \
    -num hbonds.xvg
# Seleccione 1 (Protein) tanto para donante como aceptador
```

### Trazar archivos XVG

```python
import numpy as np
import matplotlib.pyplot as plt

# Cargar datos de RMSD
data = np.loadtxt('rmsd.xvg', comments=['@', '#'])
time = data[:, 0]      # en ns
rmsd = data[:, 1] * 10 # convertir nm a Ångstroms

plt.figure(figsize=(10, 4))
plt.plot(time, rmsd)
plt.xlabel('Time (ns)')
plt.ylabel('RMSD (Å)')
plt.title('Backbone RMSD')
plt.grid(True, alpha=0.3)
plt.savefig('rmsd_plot.png', dpi=150, bbox_inches='tight')
```

### Transferir resultados

```bash
# Desde tu máquina local:
rsync -avz -e "ssh -p <ssh-port>" \
    root@<server-ip>:/workspace/lysozyme/ \
    ./md_results/
```

***

## Simulaciones multi-GPU

Para sistemas muy grandes, use múltiples GPUs con descomposición de dominio:

```bash
# Ejecución con 4 GPUs (ajuste -ntmpi para que coincida con el número de GPU)
gmx mdrun \
    -deffnm md \
    -gpu_id 0123 \
    -ntmpi 4 \
    -ntomp 4 \
    -nb gpu \
    -bonded gpu \
    -pme gpu \
    -npme 1 \
    -update gpu \
    -v
```

{% hint style="warning" %}
**Eficiencia multi-GPU:** La escalabilidad más allá de 4 GPUs suele ser beneficiosa solo para sistemas >1 millón de átomos. Para sistemas más pequeños, una sola GPU de alta gama resulta más rentable en Clore.ai.
{% endhint %}

***

## Solución de problemas

### Error fatal: Sin descarga a GPU

```bash
# Comprobar que CUDA funciona
nvidia-smi
python3 -c "import ctypes; ctypes.CDLL('libcuda.so')"

# Forzar retroceso a CPU para pruebas
gmx mdrun -deffnm md -ntmpi 1 -ntomp 16
```

### El sistema explota / Volúmenes negativos

Esto suele indicar un problema con la minimización de energía:

```bash
# Ejecutar una minimización más larga con un tamaño de paso más pequeño
# Editar em.mdp: emstep = 0.001, emtol = 100
```

### Rendimiento lento

```bash
# Comprobar la utilización de la GPU durante la ejecución
watch -n 1 nvidia-smi

# Ajustar la configuración de descarga a GPU
gmx mdrun -deffnm md -nb gpu -pme gpu -bonded gpu -update gpu \
    -ntmpi 1 -ntomp $(nproc)
```

***

## Campos de fuerza comunes

| Campo de fuerza  | Mejor para                      |
| ---------------- | ------------------------------- |
| `amber99sb-ildn` | Proteínas, uso general          |
| `charmm36m`      | Proteínas + membranas lipídicas |
| `gromos54a7`     | Moléculas similares a fármacos  |
| `oplsaa`         | Moléculas orgánicas, lípidos    |

***

## Estimación de Costos

| Simulación      | Tamaño del sistema | GPU      | Tiempo   | Costo   |
| --------------- | ------------------ | -------- | -------- | ------- |
| Proteína 10 ns  | 25K átomos         | RTX 3090 | \~2h     | \~$0.60 |
| Proteína 100 ns | 25K átomos         | A100 40G | \~6h     | \~$4.50 |
| Membrana 100 ns | 200K átomos        | A100 80G | \~12h    | \~$9    |
| Proteína 1 μs   | 25K átomos         | A100 80G | \~3 días | \~$55   |

***

## Recursos adicionales

* [Documentación de GROMACS](https://manual.gromacs.org/)
* [Tutoriales de GROMACS (Justin Lemkul)](http://www.mdtutorials.com/gmx/)
* [Contenedor NVIDIA HPC GROMACS](https://catalog.ngc.nvidia.com/orgs/hpc/containers/gromacs)
* [GROMACS en GitHub](https://github.com/gromacs/gromacs)
* [Parámetros del campo de fuerza Amber](https://ambermd.org/)
* [Constructor de membranas CHARMM-GUI](https://www.charmm-gui.org/)

***

*Ejecutar GROMACS en Clore.ai permite a los investigadores acceder a GPUs A100 y RTX 4090 a una fracción del precio de AWS o Azure — haciendo que las simulaciones MD largas sean económicamente viables para laboratorios académicos e investigadores individuales.*

***

## Recomendaciones de GPU en Clore.ai

| Caso de uso                           | GPU recomendada | Coste estimado en Clore.ai |
| ------------------------------------- | --------------- | -------------------------- |
| Desarrollo/Pruebas                    | RTX 3090 (24GB) | \~$0.12/gpu/hr             |
| Simulaciones MD estándar              | RTX 4090 (24GB) | \~$0.70/gpu/hr             |
| Sistemas grandes / ejecuciones largas | A100 80GB       | \~$1.20/gpu/hr             |

> 💡 Todos los ejemplos en esta guía pueden desplegarse en [Clore.ai](https://clore.ai/marketplace) servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/ciencia-e-investigacion/gromacs.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.