> 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-hi/science-and-research/gromacs.md).

# GROMACS आणविक गतिकी

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

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

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

***

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

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

***

## पूर्वापेक्षाएँ

* GPU किराये के साथ Clore.ai खाता
* बुनियादी Linux कमांड लाइन ज्ञान
* आणविक सिस्टम फ़ाइलें (टोपोलॉजी + निर्देशांक), या उदाहरण सिस्टम का उपयोग करें
* वैकल्पिक: दृश्यांकन के लिए स्थानीय रूप से 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
```

**Environment Variables:**

```
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 — अपना सिस्टम तैयार करें

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

यह क्लासिक GROMACS ट्यूटोरियल सिस्टम है — अपने सेटअप का परीक्षण करने के लिए बिल्कुल उपयुक्त:

```bash
# कार्यशील निर्देशिका बनाएँ
mkdir -p /workspace/lysozyme && cd /workspace/lysozyme

# लाइसोज़ाइम 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         ; सबसे तीव्र अवरोह न्यूनकरण
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 timestep)
dt                  = 0.002         ; 2 fs timestep
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 timestep)
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]      # ns में
rmsd = data[:, 1] * 10 # nm को Angstroms में बदलें

plt.figure(figsize=(10, 4))
plt.plot(time, rmsd)
plt.xlabel('समय (ns)')
plt.ylabel('RMSD (Å)')
plt.title('बैकबोन 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 सिमुलेशन

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

```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 GPU से आगे स्केल करना आमतौर पर केवल 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 | \~12 घंटे | \~$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 चलाने से शोधकर्ताओं को AWS या Azure की कीमत के एक छोटे हिस्से में A100 और RTX 4090 GPU तक पहुंच मिलती है — जिससे लंबी MD सिमुलेशन अकादमिक प्रयोगशालाओं और व्यक्तिगत शोधकर्ताओं के लिए आर्थिक रूप से व्यवहार्य हो जाती हैं।*

***

## Clore.ai GPU अनुशंसाएँ

| उपयोग-प्रकरण          | अनुशंसित GPU    | Clore.ai पर अनुमानित लागत                 |
| --------------------- | --------------- | ----------------------------------------- |
| विकास/परीक्षण         | RTX 3090 (24GB) | $0.07–0.21/gpu/hr                         |
| मानक MD सिमुलेशन      | RTX 4090 (24GB) | $0.14–0.42/gpu/hr                         |
| बड़े सिस्टम / लंबे रन | A100 80GB       | [bare metal](https://clore.ai/bare-metal) |

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


---

# 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-hi/science-and-research/gromacs.md?ask=<question>&goal=<endgoal>
```

`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.