> 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-fr/science-et-recherche/gromacs.md).

# Dynamique moléculaire GROMACS

> **Simulations de dynamique moléculaire accélérées par GPU — du repliement des protéines à la découverte de médicaments**

GROMACS (GROningen MAchine for Chemical Simulations) est le paquet de simulation de dynamique moléculaire le plus utilisé au monde. Développé à l'origine à l'université de Groningen, il est désormais maintenu par une communauté mondiale et constitue l'outil de travail des laboratoires de chimie computationnelle et de biologie structurale du monde entier.

Avec l'accélération GPU, GROMACS peut simuler des systèmes de millions d'atomes à des vitesses qui prendraient des semaines sur du matériel uniquement CPU. Les locations de GPU abordables de Clore.ai rendent les simulations MD à grande échelle accessibles aux chercheurs individuels et aux petits laboratoires.

***

## Que pouvez-vous simuler ?

* **Repliement et dynamique des protéines** — observer des changements conformationnels en nanosecondes à microsecondes
* **Liaison médicament-protéine** — calculer des énergies libres de liaison pour la découverte de médicaments
* **Simulations de membranes** — bicouches lipidiques, protéines membranaires, transport d'ions
* **Interactions protéine-protéine** — étudier la formation de complexes et la dynamique des interfaces
* **Science des matériaux** — polymères, nanoparticules, modèles d'eau
* **Calculs d'énergies libres** — transformations alchimiques, PME

***

## Prérequis

* Compte Clore.ai avec location de GPU
* Connaissances de base de la ligne de commande Linux
* Fichiers du système moléculaire (topologie + coordonnées), ou utiliser des systèmes d'exemple
* Optionnel : GROMACS localement pour la visualisation (VMD, Pymol)

***

## Pourquoi utiliser GROMACS accéléré par GPU ?

GROMACS avec déchargement GPU offre des accélérations spectaculaires :

| Taille du système | CPU uniquement (ns/jour) | A100 unique (ns/jour) | Accélération |
| ----------------- | ------------------------ | --------------------- | ------------ |
| 25K atomes        | \~50                     | \~800                 | ≈16x         |
| 100K atomes       | \~15                     | \~400                 | ≈27x         |
| 500K atomes       | \~3                      | \~150                 | ≈50x         |
| 1M atomes         | \~1                      | \~80                  | ≈80x         |

{% hint style="success" %}
**L'accélération GPU est particulièrement bénéfique pour les grands systèmes (>100K atomes).** Pour les petits systèmes de test, les performances CPU peuvent être comparables en raison des surcoûts de transfert de données.
{% endhint %}

***

## Étape 1 — Louez un GPU sur Clore.ai

1. Aller à [clore.ai](https://clore.ai) → **Place de marché**
2. Filtrer par GPU : **A100, RTX 4090 ou RTX 3090** recommandé
3. Pour les grands systèmes (>500K atomes) : choisissez A100 40GB ou 80GB
4. Pour les simulations standard : RTX 4090 ou RTX 3090 offrent un excellent rapport qualité-prix

**Spécifications recommandées :**

* GPU : A100 40GB ou RTX 4090
* CPU : 16+ cœurs (GROMACS utilise le multi-cœur pour les interactions non liées)
* RAM : 32GB+
* Disque : 50GB+ (les trajectoires peuvent être volumineuses)

***

## Étape 2 — Déployer le conteneur GROMACS

Utilisez l'image HPC officielle de NVIDIA pour GROMACS — elle est optimisée pour les GPU NVIDIA avec support CUDA :

**Image Docker :**

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

**Ports exposés :**

```
22
```

**Variables d’environnement :**

```
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 d'environnement NVIDIA pour GROMACS :**

* `GMX_GPU_DD_COMMS=true` — active les communications de décomposition de domaine basées sur le GPU
* `GMX_GPU_PME_PP_COMMS=true` — active les communications PME-PP basées sur le GPU
* `GMX_FORCE_UPDATE_DEFAULT_GPU=true` — force la mise à jour des coordonnées sur GPU (accélération significative)
  {% endhint %}

***

## Étape 3 — Se connecter et vérifier

```bash
ssh root@<server-ip> -p <ssh-port>

# Vérifier la version de GROMACS
gmx --version

# Vérifier la disponibilité du GPU
nvidia-smi

# Vérifier que GROMACS peut voir le GPU
gmx mdrun -h 2>&1 | grep -i gpu
```

La sortie attendue de `gmx --version` devrait afficher :

```
Version de GROMACS : 2023.2
Version CUDA : 11.x ou 12.x
Support GPU : CUDA
```

***

## Étape 4 — Préparez votre système

### Utilisation d'un système d'exemple (Lysozyme dans l'eau)

Il s'agit du système classique du tutoriel GROMACS — parfait pour tester votre installation :

```bash
# Créer le répertoire de travail
mkdir -p /workspace/lysozyme && cd /workspace/lysozyme

# Télécharger la structure PDB du lysozyme
wget https://files.rcsb.org/download/1AKI.pdb -O 1AKI.pdb

# Retirer les molécules d'eau de la structure cristalline
grep -v HOH 1AKI.pdb > 1AKI_clean.pdb

# Générer la topologie en utilisant le champ de force AMBER99SB
gmx pdb2gmx \
    -f 1AKI_clean.pdb \
    -o processed.gro \
    -water spce \
    -ff amber99sb-ildn
```

Lorsque vous êtes invité à sélectionner le champ de force, choisissez `amber99sb-ildn` (option 6 généralement).

***

## Étape 5 — Construire la boîte de simulation

```bash
# Définir la boîte de simulation (dodécaèdre, 1.0 nm depuis la protéine)
gmx editconf \
    -f processed.gro \
    -o boxed.gro \
    -c \
    -d 1.0 \
    -bt dodecahedron

# Solvater la boîte avec de l'eau
gmx solvate \
    -cp boxed.gro \
    -cs spc216.gro \
    -o solvated.gro \
    -p topol.top

# Ajouter des ions pour neutraliser la charge
# D'abord créer le fichier tpr pour l'ajout d'ions
gmx grompp \
    -f /usr/local/gromacs/share/gromacs/top/em.mdp \
    -c solvated.gro \
    -p topol.top \
    -o ions.tpr

# Ajouter Na+ et Cl- (0.15M NaCl)
gmx genion \
    -s ions.tpr \
    -o ionized.gro \
    -p topol.top \
    -pname NA \
    -nname CL \
    -neutral \
    -conc 0.15
# Sélectionner le groupe 13 (SOL) lorsqu'on vous le demande
```

***

## Étape 6 — Minimisation d'énergie

```bash
# Créer le fichier MDP de minimisation d'énergie
cat > em.mdp << 'EOF'
; Paramètres de minimisation d'énergie
integrator      = steep         ; Minimisation par descente la plus raide
emtol           = 1000.0        ; Arrêter quand la force max < 1000 kJ/mol/nm
emstep          = 0.01          ; Taille de pas initiale
nsteps          = 50000         ; Nombre maximum d'étapes de minimisation
nstlist         = 1
cutoff-scheme   = Verlet
ns_type         = grid
coulombtype     = PME
rcoulomb        = 1.0
rvdw            = 1.0
pbc             = xyz
EOF

# Préparer le TPR pour la minimisation d'énergie
gmx grompp \
    -f em.mdp \
    -c ionized.gro \
    -p topol.top \
    -o em.tpr

# Lancer la minimisation d'énergie sur GPU
gmx mdrun \
    -v \
    -deffnm em \
    -gpu_id 0 \
    -ntmpi 1 \
    -ntomp 8

# Vérifier que l'énergie a convergé
gmx energy -f em.edr -o em_potential.xvg
# Sélectionner 10 (Potential) puis 0 pour quitter
```

***

## Étape 7 — Équilibrage NVT (Température)

```bash
cat > nvt.mdp << 'EOF'
; Équilibrage NVT
define              = -DPOSRES      ; Contraintes de position
integrator          = md            ; Intégrateur leap-frog
nsteps              = 50000         ; 100 ps (pas de 2 fs)
dt                  = 0.002         ; pas 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
```

***

## Étape 8 — Équilibrage NPT (Pression)

```bash
cat > npt.mdp << 'EOF'
; Équilibrage 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
```

***

## Étape 9 — Course de production MD

```bash
cat > md.mdp << 'EOF'
; Course de production MD
integrator          = md
nsteps              = 5000000      ; 10 ns (pas de 2 fs)
dt                  = 0.002
nstxout-compressed  = 5000        ; Sauvegarder les coordonnées toutes les 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

# Course de production avec déchargement GPU complet
gmx mdrun \
    -deffnm md \
    -gpu_id 0 \
    -ntmpi 1 \
    -ntomp 16 \
    -nb gpu \
    -bonded gpu \
    -pme gpu \
    -update gpu \
    -v
```

{% hint style="info" %}
**Surveiller la progression en temps réel :**

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

{% endhint %}

***

## Étape 10 — Analyse

### Analyse basique des trajectoires

```bash
# RMSD (stabilité de la charpente au fil du temps)
gmx rms \
    -s md.tpr \
    -f md.xtc \
    -o rmsd.xvg \
    -tu ns
# Sélectionner 4 (Backbone) pour les groupes de référence et ajustés

# RMSF (flexibilité par résidu)
gmx rmsf \
    -s md.tpr \
    -f md.xtc \
    -o rmsf.xvg \
    -res
# Sélectionner 4 (Backbone)

# Rayon de giration (compacité)
gmx gyrate \
    -s md.tpr \
    -f md.xtc \
    -o gyrate.xvg
# Sélectionner 1 (Protein)

# Liaisons hydrogène
gmx hbond \
    -s md.tpr \
    -f md.xtc \
    -num hbonds.xvg
# Sélectionner 1 (Protein) pour donneur et accepteur
```

### Tracer les fichiers XVG

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

# Charger les données RMSD
data = np.loadtxt('rmsd.xvg', comments=['@', '#'])
time = data[:, 0]      # en ns
rmsd = data[:, 1] * 10 # convertir nm en angströms

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')
```

### Transférer les résultats

```bash
# Depuis votre machine locale :
rsync -avz -e "ssh -p <ssh-port>" \
    root@<server-ip>:/workspace/lysozyme/ \
    ./md_results/
```

***

## Simulations multi-GPU

Pour des systèmes très grands, utilisez plusieurs GPU avec décomposition de domaine :

```bash
# Exécution sur 4 GPU (ajuster -ntmpi pour correspondre au nombre 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" %}
**Efficacité multi-GPU :** Le passage au-delà de 4 GPU est généralement bénéfique seulement pour des systèmes >1 million d'atomes. Pour des systèmes plus petits, un seul GPU haut de gamme est plus rentable sur Clore.ai.
{% endhint %}

***

## Dépannage

### Erreur fatale : aucun déchargement GPU

```bash
# Vérifier que CUDA fonctionne
nvidia-smi
python3 -c "import ctypes; ctypes.CDLL('libcuda.so')"

# Forcer le basculement sur CPU pour les tests
gmx mdrun -deffnm md -ntmpi 1 -ntomp 16
```

### Le système explose / volumes négatifs

Ceci indique généralement un problème avec la minimisation d'énergie :

```bash
# Exécuter une minimisation plus longue avec une taille de pas plus petite
# Éditer em.mdp : emstep = 0.001, emtol = 100
```

### Performances lentes

```bash
# Vérifier l'utilisation du GPU pendant la course
watch -n 1 nvidia-smi

# Ajuster les paramètres de déchargement GPU
gmx mdrun -deffnm md -nb gpu -pme gpu -bonded gpu -update gpu \
    -ntmpi 1 -ntomp $(nproc)
```

***

## Champs de force courants

| Champ de force   | Idéal pour                       |
| ---------------- | -------------------------------- |
| `amber99sb-ildn` | Protéines, usage général         |
| `charmm36m`      | Protéines + membranes lipidiques |
| `gromos54a7`     | Molécules de type médicament     |
| `oplsaa`         | Molécules organiques, lipides    |

***

## Estimation des coûts

| Simulation      | Taille du système | GPU      | Temps    | Coût    |
| --------------- | ----------------- | -------- | -------- | ------- |
| 10 ns protéine  | 25K atomes        | RTX 3090 | ≈2h      | \~$0.60 |
| 100 ns protéine | 25K atomes        | A100 40G | ≈6h      | \~$4.50 |
| 100 ns membrane | 200K atomes       | A100 80G | ≈12h     | \~$9    |
| 1 μs protéine   | 25K atomes        | A100 80G | ≈3 jours | \~$55   |

***

## Ressources supplémentaires

* [Documentation GROMACS](https://manual.gromacs.org/)
* [Tutoriels GROMACS (Justin Lemkul)](http://www.mdtutorials.com/gmx/)
* [Conteneur NVIDIA HPC GROMACS](https://catalog.ngc.nvidia.com/orgs/hpc/containers/gromacs)
* [GROMACS GitHub](https://github.com/gromacs/gromacs)
* [Paramètres du champ de force Amber](https://ambermd.org/)
* [CHARMM-GUI Membrane Builder](https://www.charmm-gui.org/)

***

*Exécuter GROMACS sur Clore.ai permet aux chercheurs d'accéder aux GPU A100 et RTX 4090 à une fraction du prix AWS ou Azure — rendant les longues simulations MD économiquement viables pour les laboratoires académiques et les chercheurs individuels.*

***

## Recommandations GPU Clore.ai

| Cas d’utilisation                    | GPU recommandé  | Coût estimé sur Clore.ai |
| ------------------------------------ | --------------- | ------------------------ |
| Développement/Test                   | RTX 3090 (24GB) | \~$0.12/gpu/hr           |
| Simulations MD standard              | RTX 4090 (24GB) | \~$0.70/gpu/hr           |
| Grands systèmes / longues exécutions | A100 80GB       | \~$1.20/gpu/hr           |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.


---

# 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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/science-et-recherche/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.