> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/ciencia-e-investigacion/gromacs.md). # Dinámica molecular de 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 del mundo. Desarrollado originalmente en la Universidad de Groningen, ahora lo mantiene una comunidad global y es el caballo de batalla de los laboratorios de química computacional y biología estructural de todo el mundo. Con aceleración por GPU, GROMACS puede simular sistemas de millones de átomos a velocidades que llevarían semanas en hardware solo con CPU. Los alquileres asequibles de GPU de Clore.ai hacen que las simulaciones de dinámica molecular a gran escala sean accesibles para investigadores individuales y pequeños laboratorios. *** ## ¿Qué puedes simular? * **Plegamiento y dinámica de proteínas** — observa cambios conformacionales en nanosegundos a microsegundos * **Unión fármaco-proteína** — calcula energías libres de unión para el descubrimiento de fármacos * **Simulaciones de membranas** — bicapas lipídicas, proteínas de membrana, transporte iónico * **Interacciones proteína-proteína** — estudia la formación de complejos y la dinámica de la interfaz * **Ciencia de materiales** — polímeros, nanopartículas, modelos de agua * **Cálculos de energía libre** — transformaciones alquímicas, PME *** ## Requisitos previos * Cuenta de 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 usa sistemas de ejemplo * Opcional: GROMACS localmente para visualización (VMD, Pymol) *** ## ¿Por qué usar GROMACS acelerado por GPU? GROMACS con descarga a GPU ofrece aceleraciones espectaculares: | Tamaño del sistema | Solo CPU (ns/día) | Una sola A100 (ns/día) | Aceleración | | ------------------ | ----------------- | ---------------------- | ----------- | | 25 mil átomos | \~50 | \~800 | \~16x | | 100 mil átomos | \~15 | \~400 | \~27x | | 500 mil átomos | \~3 | \~150 | \~50x | | 1 millón de átomos | \~1 | \~80 | \~80x | {% hint style="success" %} **La aceleración por GPU es más beneficiosa para sistemas grandes (>100 mil á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 (>500 mil átomos): elige A100 de 40 GB o 80 GB 4. Para simulaciones estándar: RTX 4090 o RTX 3090 ofrecen una excelente relación calidad-precio **Especificaciones recomendadas:** * GPU: A100 de 40 GB o RTX 4090 * CPU: 16+ núcleos (GROMACS usa varios núcleos para interacciones no enlazadas) * RAM: 32 GB+ * Disco: 50 GB+ (las trayectorias pueden ser grandes) *** ## Paso 2 — Desplegar el contenedor de GROMACS Usa la imagen oficial de HPC de GROMACS de NVIDIA — está optimizada para GPU de NVIDIA con soporte CUDA: **Imagen de 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 las comunicaciones de descomposición de dominio basadas en GPU * `GMX_GPU_PME_PP_COMMS=true` — habilita las 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@ -p # Verificar la versión de GROMACS gmx --version # Verificar la disponibilidad de la GPU nvidia-smi # Verificar que GROMACS pueda 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 Compatibilidad con GPU: CUDA ``` *** ## Paso 4 — Preparar tu sistema ### Usando un sistema de ejemplo (lisozima en agua) Este es el clásico sistema tutorial de GROMACS — perfecto para probar tu configuración: ```bash # Crear el 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 las moléculas de agua de la estructura cristalina grep -v HOH 1AKI.pdb > 1AKI_clean.pdb # Generar la topología usando el campo de fuerzas AMBER99SB gmx pdb2gmx \ -f 1AKI_clean.pdb \ -o processed.gro \ -water spce \ -ff amber99sb-ildn ``` Cuando se te pida seleccionar el campo de fuerzas, elige `amber99sb-ildn` (normalmente la opción 6). *** ## Paso 5 — Construir la caja de simulación ```bash # Definir la caja de simulación (dodecaedro, a 1,0 nm de 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 crea 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ñade iones Na+ y Cl- (NaCl 0,15 M) gmx genion \ -s ions.tpr \ -o ionized.gro \ -p topol.top \ -pname NA \ -nname CL \ -neutral \ -conc 0.15 # Selecciona el grupo 13 (SOL) cuando se te 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 inicial del paso 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 el TPR para la minimización de energía gmx grompp \ -f em.mdp \ -c ionized.gro \ -p topol.top \ -o em.tpr # Ejecutar la minimización de energía en la 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 # Selecciona 10 (Potential) y 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 tiempo de 2 fs) dt = 0.002 ; Paso de tiempo 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 MD de producción ```bash cat > md.mdp << 'EOF' ; Ejecución MD de producción integrator = md nsteps = 5000000 ; 10 ns (paso de tiempo 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" %} **Supervisa 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 del esqueleto a lo largo del tiempo) gmx rms \ -s md.tpr \ -f md.xtc \ -o rmsd.xvg \ -tu ns # Selecciona 4 (Backbone) para los grupos de referencia y ajustado # RMSF (flexibilidad por residuo) gmx rmsf \ -s md.tpr \ -f md.xtc \ -o rmsf.xvg \ -res # Selecciona 4 (Backbone) # Radio de giro (compactación) gmx gyrate \ -s md.tpr \ -f md.xtc \ -o gyrate.xvg # Selecciona 1 (Protein) # Puentes de hidrógeno gmx hbond \ -s md.tpr \ -f md.xtc \ -num hbonds.xvg # Selecciona 1 (Protein) tanto para donador como para aceptor ``` ### Graficar 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 de nm a Ångstroms plt.figure(figsize=(10, 4)) plt.plot(time, rmsd) plt.xlabel('Tiempo (ns)') plt.ylabel('RMSD (Å)') plt.title('RMSD del esqueleto') 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 " \ root@:/workspace/lysozyme/ \ ./md_results/ ``` *** ## Simulaciones con varias GPU Para sistemas muy grandes, utiliza varias GPU con descomposición de dominio: ```bash # Ejecución con 4 GPU (ajusta -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 en varias GPU:** Escalar más allá de 4 GPU normalmente solo es beneficioso para sistemas de más de 1 millón de átomos. Para sistemas más pequeños, una sola GPU de gama alta es más rentable en Clore.ai. {% endhint %} *** ## Solución de problemas ### Error fatal: sin descarga a GPU ```bash # Comprueba que CUDA funciona nvidia-smi python3 -c "import ctypes; ctypes.CDLL('libcuda.so')" # Forzar la ruta de respaldo 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 # Ejecuta una minimización más larga con un tamaño de paso más pequeño # Edita em.mdp: emstep = 0.001, emtol = 100 ``` ### Rendimiento lento ```bash # Comprueba la utilización de la GPU durante la ejecución watch -n 1 nvidia-smi # Ajusta 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 fuerzas comunes | Campo de fuerzas | Ideal para | | ---------------- | ------------------------------- | | `amber99sb-ildn` | Proteínas, uso general | | `charmm36m` | Proteínas + membranas lipídicas | | `gromos54a7` | Moléculas tipo fármaco | | `oplsaa` | Moléculas orgánicas, lípidos | *** ## Estimación de costos | Simulación | Tamaño del sistema | GPU | Tiempo | Costo | | ------------------ | ------------------ | -------- | -------- | ------- | | Proteína de 10 ns | 25 mil átomos | RTX 3090 | \~2 h | \~$0.60 | | Proteína de 100 ns | 25 mil átomos | A100 40G | \~6h | \~$4.50 | | membrana de 100 ns | 200K átomos | A100 80G | \~12h | \~$9 | | proteína de 1 μs | 25 mil á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 HPC de GROMACS de NVIDIA](https://catalog.ngc.nvidia.com/orgs/hpc/containers/gromacs) * [GitHub de GROMACS](https://github.com/gromacs/gromacs) * [Parámetros del campo de fuerza Amber](https://ambermd.org/) * [Constructor de membranas de 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 largas de dinámica molecular sean económicamente viables para laboratorios académicos e investigadores individuales.* *** ## Recomendaciones de GPU para Clore.ai | Caso de uso | GPU recomendada | Costo estimado en Clore.ai | | ------------------------------------- | --------------- | ----------------------------------------- | | Desarrollo/Pruebas | RTX 3090 (24GB) | $0.07–0.21/gpu/hr | | Simulaciones MD estándar | RTX 4090 (24GB) | $0.14–0.42/gpu/hr | | Sistemas grandes / ejecuciones largas | A100 80GB | [bare metal](https://clore.ai/bare-metal) | > 💡 Todos los ejemplos de esta guía pueden desplegarse en [Clore.ai](https://clore.ai/marketplace) servidores GPU. Explora las GPUs disponibles y alquila por hora: sin compromisos, acceso root completo. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## 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, and the optional `goal` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-es/ciencia-e-investigacion/gromacs.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. 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.