# GROMACS मॉलिक्यूलर डायनेमिक्स

> **GPU-प्रसारित आणविक गतिशीलता सिमुलेशन — प्रोटीन फोल्डिंग से लेकर दवा खोज तक**

GROMACS (GROningen MAchine for Chemical Simulations) दुनिया का सबसे व्यापक रूप से उपयोग किया जाने वाला आणविक गतिशीलता सिमुलेशन पैकेज है। मूल रूप से University of Groningen में विकसित, अब इसे वैश्विक समुदाय द्वारा मेंटेन किया जाता है और यह कंप्यूटेशनल रसायन विज्ञान और संरचनात्मक जीवविज्ञान प्रयोगशालाओं का कामकाजी साधन है।

GPU त्वरक के साथ, GROMACS मिलियनों परमाणुओं के सिस्टम को उन गतिों पर सिमुलेट कर सकता है जिन्हें केवल CPU हार्डवेयर पर हफ्तों लगते। Clore.ai के किफायती GPU किराये व्यक्तिगत शोधकर्ताओं और छोटे प्रयोगशालाओं के लिए बड़े पैमाने पर MD सिमुलेशन सुलभ बनाते हैं।

***

## आप क्या सिमुलेट कर सकते हैं?

* **प्रोटीन फोल्डिंग और डायनामिक्स** — नैनोसेकंड से माइक्रोसेकंड में रूपात्मक परिवर्तन देखें
* **दवा-प्रोटीन बाइंडिंग** — दवा खोज के लिए बाइंडिंग फ्री एनर्जी की गणना करें
* **मेम्ब्रेन सिमुलेशन** — लिपिड बाइलयर्स, मेम्ब्रेन प्रोटीन, आयन परिवहन
* **प्रोटीन-प्रोटीन इंटरैक्शन्स** — जटिल गठन और इंटरफ़ेस डायनामिक्स का अध्ययन करें
* **सामग्री विज्ञान** — पॉलिमर, नैनोपार्टिकल, पानी मॉडल
* **फ्री एनर्जी गणनाएँ** — अलकेमिकल ट्रांसफॉर्मेशन, PME

***

## पूर्व-आवश्यकताएँ

* GPU किराये के साथ Clore.ai खाता
* बेसिक लिनक्स कमांड लाइन ज्ञान
* आणविक सिस्टम फाइलें (टोपोलॉजी + निर्देशांक), या उदाहरण सिस्टम का उपयोग करें
* वैकल्पिक: विज़ुअलाइज़ेशन के लिए स्थानीय रूप से GROMACS (VMD, Pymol)

***

## GPU-प्रसारित GROMACS क्यों उपयोग करें?

GPU ऑफलोडिंग के साथ GROMACS नाटकीय स्पीडअप देता है:

| सिस्टम आकार | केवल CPU (ns/दिन) | सिंगल A100 (ns/दिन) | स्पीडअप |
| ----------- | ----------------- | ------------------- | ------- |
| 25K परमाणु  | \~50              | \~800               | \~16x   |
| 100K परमाणु | \~15              | \~400               | \~27x   |
| 500K परमाणु | \~3               | \~150               | \~50x   |
| 1M परमाणु   | \~1               | \~80                | \~80x   |

{% hint style="success" %}
**GPU त्वरक बड़े सिस्टम (>100K परमाणु) के लिए सबसे अधिक लाभकारी है।** छोटे परीक्षण सिस्टम के लिए, डेटा ट्रांसफर ओवरहेड के कारण CPU प्रदर्शन तुलनीय हो सकता है।
{% endhint %}

***

## चरण 1 — Clore.ai पर एक GPU किराए पर लें

1. जाएँ [clore.ai](https://clore.ai) → **मार्केटप्लेस**
2. GPU द्वारा फ़िल्टर करें: **A100, RTX 4090, या RTX 3090** अनुशंसित
3. बड़े सिस्टम (>500K परमाणु) के लिए: A100 40GB या 80GB चुनें
4. मानक सिमुलेशनों के लिए: RTX 4090 या RTX 3090 बेहतरीन मूल्य हैं

**अनुशंसित विनिर्देश:**

* GPU: A100 40GB या RTX 4090
* CPU: 16+ कोर (GROMACS नॉन-बॉन्डेड इंटरैक्शन्स के लिए मल्टी-कोर उपयोग करता है)
* RAM: 32GB+
* डिस्क: 50GB+ (ट्राजेक्टोरियाँ बड़ी हो सकती हैं)

***

## चरण 2 — GROMACS कंटेनर तैनात करें

NVIDIA की आधिकारिक HPC GROMACS इमेज का उपयोग करें — यह CUDA सपोर्ट वाले NVIDIA GPU के लिए अनुकूलित है:

**Docker इमेज:**

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

**खुले पोर्ट:**

```
22
```

**पर्यावरण चर:**

```
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" %}
**GROMACS के लिए NVIDIA वातावरण चर:**

* `GMX_GPU_DD_COMMS=true` — GPU-आधारित डोमेन डिकम्पोज़िशन संचार सक्षम करता है
* `GMX_GPU_PME_PP_COMMS=true` — GPU-आधारित PME-PP संचार सक्षम करता है
* `GMX_FORCE_UPDATE_DEFAULT_GPU=true` — GPU निर्देशांक अपडेट को मजबूर करता है (महत्वपूर्ण स्पीडअप)
  {% endhint %}

***

## चरण 3 — कनेक्ट और सत्यापित करें

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

# GROMACS संस्करण जांचें
gmx --version

# GPU उपलब्धता जांचें
nvidia-smi

# सत्यापित करें कि GROMACS GPU देख सकता है
gmx mdrun -h 2>&1 | grep -i gpu
```

अपेक्षित आउटपुट से `gmx --version` निम्न दिखना चाहिए:

```
GROMACS संस्करण: 2023.2
CUDA संस्करण: 11.x या 12.x
GPU समर्थन: CUDA
```

***

## चरण 4 — अपना सिस्टम तैयार करें

### उदाहरण सिस्टम का उपयोग करना (पानी में लाइसोzymE)

यह क्लासिक GROMACS ट्यूटोरियल सिस्टम है — आपकी सेटअप जाँचने के लिए परफेक्ट:

```bash
# वर्किंग डायरेक्टरी बनाएं
mkdir -p /workspace/lysozyme && cd /workspace/lysozyme

# लाइसोzyme PDB संरचना डाउनलोड करें
wget https://files.rcsb.org/download/1AKI.pdb -O 1AKI.pdb

# क्रिस्टल संरचना से पानी के अणुओं को हटाएँ
grep -v HOH 1AKI.pdb > 1AKI_clean.pdb

# AMBER99SB फोर्स फील्ड का उपयोग करके टोपोलॉजी जनरेट करें
gmx pdb2gmx \
    -f 1AKI_clean.pdb \
    -o processed.gro \
    -water spce \
    -ff amber99sb-ildn
```

जब फोर्स फील्ड चयन के लिए कहा जाए, तो चुनें `amber99sb-ildn` (आमतौर पर विकल्प 6)।

***

## चरण 5 — सिमुलेशन बॉक्स बनाएं

```bash
# सिमुलेशन बॉक्स परिभाषित करें (डोडेकाहेड्रन, प्रोटीन से 1.0 nm)
gmx editconf \
    -f processed.gro \
    -o boxed.gro \
    -c \
    -d 1.0 \
    -bt dodecahedron

# बॉक्स को पानी से सॉल्वेट करें
gmx solvate \
    -cp boxed.gro \
    -cs spc216.gro \
    -o solvated.gro \
    -p topol.top

# चार्ज न्यूट्रल करने के लिए आयन जोड़ें
# पहले आयन जोड़ने के लिए tpr फाइल बनाएं
gmx grompp \
    -f /usr/local/gromacs/share/gromacs/top/em.mdp \
    -c solvated.gro \
    -p topol.top \
    -o ions.tpr

# Na+ और Cl- आयन जोड़ें (0.15M NaCl)
gmx genion \
    -s ions.tpr \
    -o ionized.gro \
    -p topol.top \
    -pname NA \
    -nname CL \
    -neutral \
    -conc 0.15
# प्रॉम्प्ट पर समूह 13 (SOL) चुनें
```

***

## चरण 6 — ऊर्जा न्यूनकरण

```bash
# ऊर्जा न्यूनकरण MDP फ़ाइल बनाएं
cat > em.mdp << 'EOF'
; ऊर्जा न्यूनकरण पैरामीटर
integrator      = steep         ; Steepest descent minimization
emtol           = 1000.0        ; अधिकतम बल < 1000 kJ/mol/nm होने पर रोकें
emstep          = 0.01          ; प्रारंभिक कदम का आकार
nsteps          = 50000         ; अधिकतम न्यूनकरण चरण
nstlist         = 1
cutoff-scheme   = Verlet
ns_type         = grid
coulombtype     = PME
rcoulomb        = 1.0
rvdw            = 1.0
pbc             = xyz
EOF

# ऊर्जा न्यूनकरण के लिए TPR तैयार करें
gmx grompp \
    -f em.mdp \
    -c ionized.gro \
    -p topol.top \
    -o em.tpr

# GPU पर ऊर्जा न्यूनकरण चलाएँ
gmx mdrun \
    -v \
    -deffnm em \
    -gpu_id 0 \
    -ntmpi 1 \
    -ntomp 8

# जाँचें कि ऊर्जा अभिसरित हुई या नहीं
gmx energy -f em.edr -o em_potential.xvg
# बाहर निकलने के लिए 10 (Potential) चुनें फिर 0 दबाएँ
```

***

## चरण 7 — NVT संतुलन (तापमान)

```bash
cat > nvt.mdp << 'EOF'
; NVT संतुलन
define              = -DPOSRES      ; पोजिशन रेस्ट्रेंट्स
integrator          = md            ; लीप-फ्रॉग इंटीग्रेटर
nsteps              = 50000         ; 100 ps (2 fs टाइमस्टेप)
dt                  = 0.002         ; 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
```

***

## चरण 8 — NPT संतुलन (दबाव)

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

***

## चरण 9 — प्रोडक्शन MD रन

```bash
cat > md.mdp << 'EOF'
; प्रोडक्शन MD रन
integrator          = md
nsteps              = 5000000      ; 10 ns (2 fs टाइमस्टेप)
dt                  = 0.002
nstxout-compressed  = 5000        ; हर 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

# पूर्ण GPU ऑफलोड प्रोडक्शन रन
gmx mdrun \
    -deffnm md \
    -gpu_id 0 \
    -ntmpi 1 \
    -ntomp 16 \
    -nb gpu \
    -bonded gpu \
    -pme gpu \
    -update gpu \
    -v
```

{% hint style="info" %}
**रियल टाइम में प्रगति मॉनिटर करें:**

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

{% endhint %}

***

## चरण 10 — विश्लेषण

### बेसिक ट्राजेक्टोरी विश्लेषण

```bash
# RMSD (बैकबोन स्थिरता समय के साथ)
gmx rms \
    -s md.tpr \
    -f md.xtc \
    -o rmsd.xvg \
    -tu ns
# संदर्भ और फिट किए गए समूह दोनों के लिए 4 (Backbone) चुनें

# RMSF (प्रति-अवशेष लचीलापन)
gmx rmsf \
    -s md.tpr \
    -f md.xtc \
    -o rmsf.xvg \
    -res
# 4 (Backbone) चुनें

# गायरशन रेडियस (घनत्व)
gmx gyrate \
    -s md.tpr \
    -f md.xtc \
    -o gyrate.xvg
# 1 (Protein) चुनें

# हाइड्रोजन बंध
gmx hbond \
    -s md.tpr \
    -f md.xtc \
    -num hbonds.xvg
# दाता और स्वीकर्ता दोनों के लिए 1 (Protein) चुनें
```

### XVG फ़ाइलें प्लॉट करें

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

# RMSD डेटा लोड करें
data = np.loadtxt('rmsd.xvg', comments=['@', '#'])
time = data[:, 0]      # नैनोसेकंड में
rmsd = data[:, 1] * 10 # nm को आंगस्ट्रॉम में परिवर्तित करें

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

### परिणाम स्थानांतरित करें

```bash
# अपनी लोकल मशीन से:
rsync -avz -e "ssh -p <ssh-port>" \
    root@<server-ip>:/workspace/lysozyme/ \
    ./md_results/
```

***

## मल्टी-GPU सिमुलेशन

बहुत बड़े सिस्टम के लिए, डोमेन डिकम्पोज़िशन के साथ कई GPUs का उपयोग करें:

```bash
# 4-GPU रन (GPU की संख्या से मेल खाने के लिए -ntmpi समायोजित करें)
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" %}
**मल्टी-GPU दक्षता:** 4 GPUs से आगे स्केलिंग सामान्यतः केवल >1 मिलियन परमाणु वाले सिस्टम के लिए लाभकारी होती है। छोटे सिस्टम के लिए, Clore.ai पर एक उच्च-स्तरीय सिंगल GPU अधिक लागत-प्रभावी है।
{% endhint %}

***

## समस्या निवारण

### घातक त्रुटि: कोई GPU ऑफलोड नहीं

```bash
# जांचें कि CUDA काम कर रहा है
nvidia-smi
python3 -c "import ctypes; ctypes.CDLL('libcuda.so')"

# टेस्टिंग के लिए CPU फ़ॉलबैक मजबूर करें
gmx mdrun -deffnm md -ntmpi 1 -ntomp 16
```

### सिस्टम विस्फोट / नकारात्मक आयतन

यह आमतौर पर ऊर्जा न्यूनकरण में समस्या का संकेत देता है:

```bash
# छोटे स्टेप साइज़ के साथ लंबा न्यूनकरण चलाएँ
# em.mdp संपादित करें: emstep = 0.001, emtol = 100
```

### धीमा प्रदर्शन

```bash
# रन के दौरान GPU उपयोगिता जांचें
watch -n 1 nvidia-smi

# GPU ऑफलोड सेटिंग्स ट्यून करें
gmx mdrun -deffnm md -nb gpu -pme gpu -bonded gpu -update gpu \
    -ntmpi 1 -ntomp $(nproc)
```

***

## सामान्य फोर्स फील्ड्स

| फोर्स फील्ड      | माध्य/दिन                 |
| ---------------- | ------------------------- |
| `amber99sb-ildn` | प्रोटीन, सामान्य उपयोग    |
| `charmm36m`      | प्रोटीन + लिपिड मेम्ब्रेन |
| `gromos54a7`     | दवा सदृश अणु              |
| `oplsaa`         | कार्बनिक अणु, लिपिड       |

***

## लागत अनुमान

| सिमुलेशन         | सिस्टम आकार | GPU      | समय     | लागत    |
| ---------------- | ----------- | -------- | ------- | ------- |
| 10 ns प्रोटीन    | 25K परमाणु  | RTX 3090 | \~2h    | \~$0.60 |
| 100 ns प्रोटीन   | 25K परमाणु  | A100 40G | \~6h    | \~$4.50 |
| 100 ns मेम्ब्रेन | 200K परमाणु | A100 80G | \~12h   | \~$9    |
| 1 μs प्रोटीन     | 25K परमाणु  | A100 80G | \~3 दिन | \~$55   |

***

## अतिरिक्त संसाधन

* [GROMACS दस्तावेज़](https://manual.gromacs.org/)
* [GROMACS ट्यूटोरियल्स (Justin Lemkul)](http://www.mdtutorials.com/gmx/)
* [NVIDIA HPC GROMACS कंटेनर](https://catalog.ngc.nvidia.com/orgs/hpc/containers/gromacs)
* [GROMACS GitHub](https://github.com/gromacs/gromacs)
* [Amber फोर्स फील्ड पैरामीटर](https://ambermd.org/)
* [CHARMM-GUI मेम्ब्रेन बिल्डर](https://www.charmm-gui.org/)

***

*Clore.ai पर GROMACS चलाने से शोधकर्ताओं को A100 और RTX 4090 GPUs तक AWS या Azure की कीमतों के एक अंश पर पहुँच मिलती है — जिससे लंबे MD सिमुलेशन अकादमिक लैब और व्यक्तिगत शोधकर्ताओं के लिए आर्थिक रूप से व्यावहारिक बन जाते हैं।*

***

## Clore.ai GPU सिफारिशें

| उपयोग केस             | सिफारिश की गई GPU | Clore.ai पर अनुमानित लागत |
| --------------------- | ----------------- | ------------------------- |
| डेवलपमेंट/टेस्टिंग    | RTX 3090 (24GB)   | \~$0.12/gpu/hr            |
| मानक MD सिमुलेशन      | RTX 4090 (24GB)   | \~$0.70/gpu/hr            |
| बड़े सिस्टम / लंबे रन | A100 80GB         | \~$1.20/gpu/hr            |

> 💡 इस गाइड के सभी उदाहरण तैनात किए जा सकते हैं [Clore.ai](https://clore.ai/marketplace) GPU सर्वरों पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।