Skip to content

OpenMM/fr

Introduction

OpenMM (Site Web OpenMM) est une boîte d'outils conçue pour la simulation moléculaire. On peut l'utiliser seule comme application pour effectuer des simulations ou comme bibliothèque que vous appelez à partir de votre code. OpenMM est un paquet unique de par sa très grande flexibilité des champs de force personnalisés et des algorithmes de résolution (ou d’intégration), son ouverture et son excellente performance, en particulier avec les GPU récents.

Points forts

  • Interface Python flexible avec des classes de haut niveau et un accès API de bas niveau pour des flux de travail personnalisés.
  • Cadre de plug-in de haut niveau pour les potentiels basés sur l'apprentissage machine (ML) et les simulations hybrides.
  • Exécution efficace sur les CPU et les GPU, adaptée aux plateformes de calcul haute performance (CHP).
  • Prise en charge native des principaux formats biomoléculaires (AMBER, GROMACS, CHARMM).
  • Logiciel libre avec un écosystème actif de plug-ins pour l'apprentissage machine (ML) et les champs de force avancés.

Points faibles

  • Plus lent que les moteurs de MM classiques hautement optimisés (GROMACS, AMBER) pour les simulations de production à grande échelle.
  • La flexibilité peut complexifier les simulations hybrides ML/MM.
  • L'analyse de trajectoire spécialisée peut nécessiter des outils externes.

Modules d'environnement

module load StdEnv/2023 gcc/12.3 openmpi/4.1.5 cuda/12.6 openmm/8.4.0 ambertools/25.0

À noter

Le module ambertools est optionnel; il est requis seulement si vous prévoyez simuler des systèmes préparés avec AMBER.

Optionnellement, créez un environnement virtuel Python si vous souhaitez installer des paquets supplémentaires (par exemple, des potentiels d'apprentissage machine (ML)).

Préparation des fichiers d'entrée

OpenMM peut lire directement les fichiers de topologie et de coordonnées/redémarrage d'Amber si vous simulez des systèmes AMBER.

Assurez-vous que votre système est équilibré et minimisé dans Amber ou un autre logiciel avant de transférer les fichiers vers la plateforme de calcul haute performance (CHP).

Pour les systèmes GROMACS ou CHARMM, OpenMM peut lire leurs formats respectifs sans l'aide d'AmberTools.

Soumettre une tâche

Le script suivant est pour une tâche de simulation qui utilise un GPU.

# submit_openmm.cuda.sh
#!/bin/bash
#SBATCH --cpus-per-task=1
#SBATCH --gpus=h100:1
#SBATCH --mem-per-cpu=4000
#SBATCH --time=0-01:00:00

module purge
module load StdEnv/2023 gcc/12.3 openmpi/4.1.5 cuda/12.6 openmm/8.4.0 ambertools/25.0

python openmm_input.py

Ici, openmm_input.py est un script Python qui charge des fichiers Amber, crée le système de simulation OpenMM, configure l'intégration et exécute les dynamiques (voir cet exemple).

# openmm_input.py
import os, sys, time
import openmm.app as app
from openmm import app, unit, Platform, LangevinMiddleIntegrator, MonteCarloBarostat
from parmed import load_file
from parmed.openmm import RestartReporter, NetCDFReporter

# Simulation parameters
nsteps = 6000
dt = 2.0 * unit.femtoseconds
temperature = 310 * unit.kelvin
pressure = 1 * unit.atmosphere
cutoff = 8.0 * unit.angstroms

# Load AMBER topology and restart (only for AMBER systems)
amber_sys=load_file("prmtop.parm7", "restart.rst7")
ncrst=app.amberinpcrdfile.AmberInpcrdFile("restart.rst7")

# Create OpenMM system
system=amber_sys.createSystem(
            nonbondedMethod=app.PME,
            ewaldErrorTolerance=0.0005,
            nonbondedCutoff=cutoff,
            constraints=app.HBonds,
            removeCMMotion = True,
)

# Langevin integrator
integrator = LangevinMiddleIntegrator(temperature, 1.0/unit.picoseconds, dt)

# Monte Carlo barostat
barostat = MonteCarloBarostat(pressure, temperature, 50)
system.addForce(barostat)

# CUDA platform properties
platform = Platform.getPlatformByName("CUDA")

prop = dict(
    CudaPrecision="mixed",
    UseCpuPme='false',
    DeterministicForces="false",
    DeviceIndex=os.environ["CUDA_VISIBLE_DEVICES"],
   )

# Create simulation object
sim = app.Simulation(amber_sys.topology, system, integrator, platform, prop)
sim.context.setPositions(amber_sys.positions)
sim.context.setVelocities(ncrst.velocities)

# Reporters
sim.reporters.append(
        app.StateDataReporter(
            sys.stdout,
            1000,
            step=True,
            time=False,
            potentialEnergy=True,
            kineticEnergy=True,
            temperature=True,
            volume=True
        )
)

sim.reporters.append(NetCDFReporter("trajectory.nc", 50000, crds=True))
sim.reporters.append(RestartReporter("restart.nc", 50000, netcdf=True))

# Run dynamics
print("Running dynamics")
start = time.time()
sim.step(nsteps)
elapsed=time.time() - start
simulated_ns = (nsteps * dt).value_in_unit(unit.nanoseconds)
ns_per_day = simulated_ns / (elapsed / 86400)
print(f"Elapsed time: {elapsed} sec\nBenchmark time: {ns_per_day} ns/day ")

Performance et étalonnage (benchmarking)

Le guide Molecular Dynamics Performance Guide a été créé par une équipe d'ACENET. Le guide décrit les conditions optimales pour exécuter aussi des tâches sur nos grappes avec AMBER, GROMACS et NAMD.

Sur la plateforme CUDA, OpenMM n'a besoin que d'un CPU par GPU parce que les CPU ne sont pas utilisés pour les calculs. OpenMM peut utiliser plusieurs GPU dans un nœud, mais il est plus efficace de faire les simulations avec un seul GPU. Comme le démontrent les essais sur Narval et ceux sur Cedar, la vitesse de simulation avec plusieurs GPU est légèrement augmentée sur les nœuds avec NvLink où les GPU sont directement connectés. Sans NvLink, la vitesse de simulation augmente très peu avec des GPU P100 (essais sur Cedar).