Skip to content

About

Open-source DUck (Dynamic Undocking)

Resources

Stars

13 stars

Watchers

1 watching

Forks

 
 

Repository files navigation

Version License

Welcome to OpenDUck

OpenDUck is an open-source implementation of dynamic undocking (DUck), an application of steered molecular dynamics developed as a fast algorithm to calculate the work necessary to reach a quasi-bound state, at which a certain native contact is broken between the ligand and receptor. Due to its cheap and fast nature, DUck is mainly employed as a post-docking filter during virtual screening campaigns.

More details can be found in the original dynamic undocking publication:

Ruiz-Carmona, S., Schmidtke, P., Luque, F. et al. Dynamic undocking and the quasi-bound state as tools for drug discovery. Nature Chem 9, 201–206 (2017). https://doi.org/10.1038/nchem.2660

OpenDUck can be used as a command line tool (openduck) or as a Python library (duck). It prepares the system (receptor chunking, ligand/receptor parameterization and solvation), runs the DUck protocol in OpenMM, or writes the inputs and job scripts to run it with AMBER, and analyses the results (WQB and Jarzynski ΔGQB).

The library is also the base for new steering protocols. openduck-crooks is one: it breaks and reforms the interaction and obtains its free energy with the Crooks fluctuation theorem. examples/ also shows DUck of water bridges and of zinc-coordinating ligands, and a protocol written directly with the library.

Installation

We recommend you install OpenDUck into a fresh Conda environment with packages from conda-forge (e.g. with Miniforge).

git clone git@github.com:CBDD/openduck.git
cd openduck
conda env create -f environment.yaml
conda activate openduck
pip install .            # or `pip install -e .` for development

There are two environment files:

  • environment.yaml has the newest versions that pass the tests: Python 3.14, OpenMM 8.6.1, AmberTools 26.0 and openff-toolkit 0.19.0. It installs CUDA 12.9 libraries, so OpenMM needs an NVIDIA driver for CUDA 12.9 or newer ("CUDA Version" in nvidia-smi).
  • environment-py39.yaml is the environment of the published validation: Python 3.9, OpenMM 7.5.1, AmberTools 22 and CUDA 11.7. Use it to reproduce those results exactly, or with older drivers. It creates the environment openduck-py39.

Python 3.10–3.13 also work (see Tested platforms).

Run the unit tests with python -m pytest tests (-m "not slow" skips the two ligand parametrizations, a few minutes each). Run an end-to-end smoke test with ./test.sh DATA_DIR [GPU_ID]; the header of test.sh lists the input files it needs.

Containers

Apptainer/Singularity and Docker images are built from the repository root and contain the conda environment of environment.yaml. Add --build-arg ENV_FILE=environment-py39.yaml to build the published one instead.

apptainer build openDUck.sif openDUck_singularity.def    # or singularity build; runs the unit tests (--notest skips them)
apptainer exec --nv openDUck.sif openduck -h

docker build -t openduck .
docker run --rm --gpus all -v "$PWD":/work -w /work openduck openduck -h

OpenDUck usage

$ openduck -h
usage: openduck [-h]  ...

Open-source toolkit for dynamic undocking.

Open-source dynamic undocking toolkit. Choose one of the following actions:
    openmm-prepare      Preparation of systems for OpenMM simulations.
    openmm-full-protocol
                        OpenDUck full OpenMM protocol.
    openmm-from-equilibrated
                        OpenDUck OpenMM protocol starting from a pre-equilibrated system.
    openmm-from-amber   OpenDUck OpenMM protocol starting from an AMBER topology and coordinates.
    amber-prepare       Preparation of systems, inputs and queue files for AMBER simulations.
    report              Generate a report for OpenDUck results.
    chunk               Chunk a protein for dynamic undocking.
    prepare-cofactor    Create the parameters file for a cofactor to input as custom forcefield.

Every subcommand prints its options with openduck <subcommand> -h.

Input yaml files

Every subcommand accepts its options either on the command line or in a yaml file given with -y. The keys are the long option names with underscores (--smd-cycles → smd_cycles); ligand_mol and receptor_pdb are also accepted for ligand and receptor. Values are converted and validated like command-line values, unknown keys are reported, and options given on the command line take precedence over the yaml file, so a yaml file can be reused while changing a single option:

openduck openmm-full-protocol -y input.yaml --smd-cycles 5

Commented examples for each subcommand are in duck/templates/yaml_templates.

Running OpenDUck with OpenMM

The OpenMM route is divided in two steps, the preparation with openmmforcefields and the production (MD/SMD) following the dynamic undocking protocol:

  • openmm-full-protocol: executes the full OpenDUck protocol, from the protein-ligand files to the steered simulations.
  • openmm-prepare: chunking (optional), preparation and (with --do-equilibrate) equilibration.
  • openmm-from-equilibrated: production of MD/SMD runs from an equilibrated checkpoint (equil.chk) and its preparation pickle (complex_system.pickle).
  • openmm-from-amber: equilibration and production starting from an AMBER topology and coordinates.

The full protocol executes the following steps:

* Chunking (optional): residues within --cutoff of the interaction atom, capped and protonated with tleap
* Preparation
  * Ligand parametrization (SMIRNOFF or GAFF2, AM1-BCC charges)
  * Receptor parametrization (amber99sb or amber14-all, plus an optional custom XML force field)
  * Solvation box (cubic, --solvent-buffer-distance) with structural waters, Na+/Cl- at --ionic-strength
* Equilibration: minimisation, 100 ps NVT heating, 100 ps NPT
* (MD + SMD@300K + SMD@325K + WQB check) x smd-cycles

The OpenMM DUck protocol

The OpenMM production mirrors the AMBER DUck inputs in duck/templates/amber_inputs:

Phase Settings
MD (md_length, 0.5 ns) 300 K, Langevin (γ = 4 ps-1), PME with a 9 Å cutoff, H-bonds constrained; the key H-bond is kept formed by the flat-bottom restraint of dist_md.rst (k = 1/10 kcal mol-1 Å-2 below 2 Å / above 3 Å)
SMD at 300 K and 325 K both from the end of the MD; the H-bond distance is steered from init_distance (2.5 Å) to init_distance + 2.5 Å at 5 Å/ns with E = k (r − r0)2, k = 50 kcal mol-1 Å-2, as dist_duck.rst with jar=1
Restraints chunk heavy atoms restrained to the equilibrated coordinates with 1 kcal mol-1 Å-2 (restraint_wt, -ref 3_eq.rst); solvent, ions and the ligand are free
Time step 2 fs, or 4 fs with --HMR (same simulated times: the SMD always lasts 500 ps)

Like AMBER's jar=1, the steering restraint acts between the two H-bond atoms, so there is no steering vector to update. Its reference distance r0 advances every 0.1 ps (5000 increments of 0.0005 Å, the resolution of AMBER's DUMPAVE), and the work of each increment is computed exactly from the analytic derivative of the restraint energy, without copying coordinates from the GPU. The whole production (all MD and SMD runs of all cycles) runs in a single OpenMM Context.

Performance notes:

  • --precision mixed (default) is the equivalent of AMBER's SPFP. double is 10–50 times slower on consumer GPUs.
  • --HMR doubles the speed (4 fs time step); the system is prepared with repartitioned hydrogen masses.
  • DCD trajectories are written every --trajectory-interval ps (4 ps by default, ~20 MB per SMD for a 15k-atom system); use --trajectory-interval 0 in virtual screening.
  • On an RTX 3070, 10–18k-atom systems run at 430–480 ns/day (2 fs) and 820–880 ns/day (4 fs, HMR) in both MD and SMD: a 500 ps SMD of an 18.5k-atom system takes 96 s (52 s with HMR), against ~32 min with OpenDUck ≤ 0.2.

Runs can be resumed: relaunching openmm-from-equilibrated, or openmm-full-protocol/openmm-prepare with --resume, reuses the finished preparation, equilibration, MD (duck_runs/md_{i}.chk) and SMD (duck_runs/smd_{i}_{T}.pdb) runs. Old checkpoints written in double precision are read transparently.

openmm-full-protocol

$ openduck openmm-full-protocol -l brd4_lig.mol -r 4LR6_aligned_chunk_nowat.pdb -i A_ASN_140_ND2 \
                                -g 0 -f GAFF2 -ff amber14-all -w tip3p -W 6 -n 20 -H

or, with the parameters in a yaml file, openduck openmm-full-protocol -y input.yaml with:

# Main Arguments
interaction : A_ASN_140_ND2
receptor_pdb : 4LR6_aligned_chunk_nowat.pdb
ligand_mol : brd4_lig.mol
gpu_id : 0

# Chunking Arguments
do_chunk : True
cutoff : 10
ignore_buffers : False

# Preparation Arguments
small_molecule_forcefield : smirnoff
protein_forcefield : amber14-all
water_model : tip3p
ionic_strength : 0.05
waters_to_retain : waters_to_retain.pdb
solvent_buffer_distance : 15
force_constant_eq : 1
HMR : True

# Production Arguments
smd_cycles : 20
md_length : 0.5
wqb_threshold : 6
init_distance : 2.5
trajectory_interval : 0

Main options (see openduck openmm-full-protocol -h for all of them):

Option Default Description
-l/--ligand, -r/--receptor, -i/--interaction ligand (MOL/SDF), receptor PDB and receptor atom of the H-bond as chain_resname_resid_atomname
--do-chunk, -c/--cutoff off, 9 Å reduce the receptor to the residues within the cutoff of the interaction atom
-f, -ff, -w SMIRNOFF, amber99sb, tip3p small molecule force field (SMIRNOFF, GAFF2), protein force field (amber99sb, amber14-all) and water model (tip3p, spce)
-ion, -s, -water, -cf, -fl 0.1 M, 10 Å, waters_to_retain.pdb ionic strength, box buffer, structural waters (used if the file exists), custom XML force field, simple ligand fixes
-H/--HMR off hydrogen mass repartitioning and 4 fs time step
-n/--smd-cycles, -m/--md-length, -W/--wqb-threshold 20, 0.5 ns, none MD/SMD cycles, MD length per cycle and early-stop WQB threshold
--equilibrations 1 independent equilibrations, each followed by --smd-cycles cycles in EQ_<k>/ (see Independent equilibrations)
-d/--init-distance, -v/--init-velocities 2.5 Å, 1e-5 Å/2 fs initial SMD distance and steering speed (1e-5 Å per 2 fs = 5 Å/ns)
--force-constant-chunk, --smd-spring-constant 1.0, 50 chunk restraint and steering spring constant (kcal mol-1 Å-2, AMBER convention)
-g/--gpu-id, --precision, --integrator, --trajectory-interval CPU, mixed, langevin, 4 ps execution options
-B/--batch, -t/--threads, --resume, -i0, -p multi-ligand SDF: each ligand is prepared in parallel in {prefix}_{n} and then simulated sequentially on the GPU; a failing ligand is reported and skipped

Batch launching OpenMM SLURM jobs with openmm_job_launcher

For larger sets of ligands, openmm_job_launcher splits a multi-ligand SDF into batches, writes the input SDF and yaml files of each job and submits them to SLURM (optionally inside a Singularity container, on CPU or GPU):

openmm_job_launcher --ligand my_ligands.sdf --protein receptor.pdb --interaction A_ASN_140_ND2 --output jobs_output --jobs 4 --gpu --smd-cycles 5
openmm_job_launcher --ligand my_ligands.sdf --protein receptor.pdb --interaction A_ASN_140_ND2 --output jobs_output --jobs 10 --gpu --singularity openDUck.sif

If a native openduck installation is not found, the launcher uses openDUck.sif from the launch directory. Run openmm_job_launcher --help for all options.

openmm-prepare & openmm-from-equilibrated

The protocol can also be executed in two steps, the preparation and equilibration (openmm-prepare --do-equilibrate) and the production (openmm-from-equilibrated):

# openmm-prepare input.yaml
ligand_mol : '1a28_lig.mol'
receptor_pdb : '1a28_prot.pdb'
interaction : 'A_ARG_766_NH2'
do_chunk : True
cutoff : 10
small_molecule_forcefield : 'GAFF2'
protein_forcefield : 'amber14-all'
water_model : 'spce'
ionic_strength : 0.1
solvent_buffer_distance : 12
do_equilibrate : True
gpu_id : 0
# openmm-from-equilibrated input.yaml
equilibrated_system : equil.chk
pickle : complex_system.pickle
smd_cycles : 20
md_length : 0.5
wqb_threshold : 6
gpu_id : 0

openmm-from-amber

The protocol can be launched from an AMBER topology and coordinates (e.g. from amber-prepare). The receptor chunk (PDB or MOE mol2) is used to locate the interaction atom with the original residue numbering:

openduck openmm-from-amber -t system_complex.prmtop -c system_complex.inpcrd -r receptor_chunk.pdb -i A_ASN_140_ND2 -n 20 -W 6 -g 0

Running OpenDUck in AMBER

Dynamic undocking was originally designed to run in AMBER; OpenDUck keeps the same protocol, replacing the parametrization and file generation previously done with MOE. amber-prepare shares the preparation options of the OpenMM route and writes the pmemd inputs (1_min.in, 2_heating*.in, 3_eq.in, md.in, duck.in, duck_325K.in, dist_md.rst, dist_duck.rst), the topology (system_complex.prmtop, HMR_system_complex.prmtop with -H) and a job script built from a queue template (-q local|Slurm|SGE).

openduck amber-prepare -l 1a28_lig.mol -r 1a28_prot.pdb -i A_ARG_766_NH2 --do-chunk -c 10 \
                       -f GAFF2 -ff amber99sb -w spce -ion 0.05 -s 11 -H -n 4 -W 4 -q Slurm

Typically, dynamic undocking is employed as a post-docking filter in a virtual screening campaign. A batch preparation is executed with --batch and a multi-ligand SD-file; each ligand is prepared in the LIG_target_{n} subfolder, where n is the ligand's position in the input SDF, and an array job script is written (with the local template, one script is written in every ligand folder).

openduck amber-prepare -l brd4_ligands.sdf -r 4LR6_aligned_chunk_nowat.pdb -i A_ASN_140_ND2 \
                       --waters-to-retain waters_to_retain.pdb -f gaff2 -ff amber14-all -w spce -ion 0.1 -s 11 \
                       -H --smd-cycles 10 --wqb-threshold 6 -q SGE --seed -1 --batch --threads 8

The queueing templates are stored in duck/templates/queueing_templates. To customize a template, add a file named {queue_name}.q (single job) or {queue_name}_array.q (array job) with the following format:

#!/bin/bash
#HEADER

{functions}

{commands}

Analysis

The report subcommand compiles the results of AMBER (DUCK_*/duck.dat) and OpenMM (duck_runs/smd_*.dat) runs; the layout is detected automatically (-f auto). By default the lowest WQB over the replicas is reported. A more formally appropriate descriptor is the ΔGQB obtained with the Jarzynski equality (-d jarzynski), whose uncertainty is estimated by bootstrapping the replicas (-s replicas per sample, -i samples, --seed for reproducible numbers).

usage: openduck report [-h] [-p PATTERN] [-d {min,single,avg,jarzynski,all}] [-o OUTPUT]
                          [-of {csv,sdf,tbl}] [--plot] [-s SUBSAMPLE_SIZE] [-i ITERATIONS]
                          [-t STEP_THRESHOLD] [-f {auto,amber,openmm}] [--seed SEED]

When analyzing a single result, the default pattern is the current directory (.). To analyze multiple directories, give a wildcard pattern:

For example, the same progesterone receptor H-bond (1a28, ARG766 NH2) simulated from the same equilibrated system with AMBER (amber/, 21 cycles) and with the OpenMM engine (openmm/, 20 cycles), both with HMR:

$ openduck report -p '*/' -d all --seed 1
System   WQB    Average  SD     Jarzynski  Jarzynski_SD  Jarzynski_SEM  ...
amber/   6.381  7.505    0.596  7.207      0.169         0.027
openmm/  6.059  7.635    0.575  7.253      0.308         0.049

SMD reports use the AMBER jar=1 layout in both engines: one row per 0.1 ps with the target distance r0 (Å), the distance r (Å), the force −2k(r − r0) (kcal mol-1 Å-1) and the accumulated work (kcal/mol). Reports written by OpenDUck ≤ 0.2 (10 columns with units, 1250 rows) are still read.

Independent equilibrations

All the cycles of a DUck run start from one equilibrated structure, which is also the reference of the chunk restraints (-ref 3_eq.rst). Their WQBs are almost uncorrelated from one cycle to the next, but they share an offset set by the equilibration. In the AMBER validation data (406 H-bonds run twice with the same inputs and separate equilibrations), the mean WQB of 20 cycles differs by 2.9 kcal/mol (RMS) between the two equilibrations, against 0.7 kcal/mol between two blocks of 20 cycles of the same equilibration and 0.5 kcal/mol expected from the cycle noise. The bootstrap error of a run cannot see this offset.

With --equilibrations N (openmm-full-protocol, openmm-from-amber and amber-prepare, in openduck and openduck-crooks), the prepared system is equilibrated N times and each equilibration runs its own --smd-cycles cycles in EQ_<k>/ (k = 0 … N−1):

  • OpenMM: EQ_<k>/equil.chk and EQ_<k>/duck_runs/ (or crooks_runs/); --resume reuses the finished equilibrations and cycles.
  • AMBER: the job script runs the whole protocol (minimisation, heating, equilibration and production) inside each EQ_<k>/, with the inputs and topology linked from the run folder. The seeds must be random (--seed -1). A WQB below the threshold stops the whole run.

report (in both executables) pools the cycles of all the equilibrations and bootstraps them in two stages, first the equilibrations and then the cycles, so the errors include the variation between equilibrations. With the same number of SMDs, e.g. --equilibrations 4 --smd-cycles 5 instead of 20 cycles, an equilibration costs about as much as one cycle (1.4 ns in AMBER, 0.2 ns in OpenMM, against 1.5 ns per cycle).

benchmarks/equilibration_reproducibility.py measures whether this makes repeated runs agree: it runs every layout (e.g. 1x20, 4x5, 20x1) several times for the selected validation systems and compares the spread between repeats with the error reported by each run.

python benchmarks/equilibration_reproducibility.py suggest -n 12      # systems spanning the AMBER spread
python benchmarks/equilibration_reproducibility.py jobs --out-root REPRO --only <systems> --layouts 1x20 4x5 20x1 --repeats 3
python benchmarks/equilibration_reproducibility.py analyse --out-root REPRO --only <systems> --plot

Benchmarking OpenMM against AMBER

Two scripts in benchmarks/ re-run AMBER DUck validation sets (folders <dataset>/<pdb>/<interaction>/<condition> listed in <dataset>/systems.txt) with the OpenMM engine on exactly the same prepared systems (same topology, coordinates and steered atom pair) and compare both engines. Every OpenMM production also writes duck_runs/timings.csv with the wall time, speed and GPU of each MD and SMD run.

# run (resumable); results in OUT/<dataset>/<pdb>/<interaction>/GAFF2_openMM/ with DUCK_<n>/duck.dat as in AMBER
python benchmarks/run_openmm_validation.py run --data-root openduck_validation --out-root OUT --gpu-id 0
python benchmarks/run_openmm_validation.py jobs --data-root openduck_validation --out-root OUT   # SGE (A40) / Slurm arrays
# compare execution times and the WQB / Jarzynski dG_QB regression
python benchmarks/compare_openmm_amber.py --openmm-root OUT --data-root openduck_validation --jobs 8

Bidirectional pulls and the Crooks fluctuation theorem (openduck-crooks)

openduck-crooks runs DUck-style cycles in which each forward pull (2.5 → 5 Å) is followed by a reverse pull (5 → 2.5 Å) from its final coordinates with new velocities. The free energy is the crossing of the forward and reverse work distributions (Crooks fluctuation theorem, thesis ch. 6.4), reported with the Gaussian intersection, BAR and Jarzynski estimates, bootstrap errors and the DUck WQB/ΔGQB of the forward pulls. It has the same input conventions (yaml files, preparation options, water steering, custom force fields) and both engines:

$ openduck-crooks -h
    openmm-full-protocol      Preparation, equilibration and bidirectional pulls in OpenMM.
    openmm-from-equilibrated  Bidirectional pulls in OpenMM from an equilibrated system.
    openmm-from-amber         Bidirectional pulls in OpenMM from an AMBER topology and coordinates.
    amber-prepare             Preparation, pmemd inputs and job script of the bidirectional protocol.
    report                    Free energies and plots of finished bidirectional runs.
openduck-crooks openmm-full-protocol -y examples/hbond/crooks-openmm-full-protocol.yaml
openduck-crooks report -p '*/' --plot -o crooks_report.tbl

See examples/README.md for the protocol, its options (speed, spring, approach, reverse velocities, MD restraint window), how to reproduce the thesis settings and the water-bridge and zinc examples.

Using OpenDUck as a Python library

from duck.steps.production import DuckSimulation, run_duck_cycles
from duck.utils.duck_stuff import load_complex_pickle

# full production from an equilibrated system
run_duck_cycles('equil.chk', 'complex_system.pickle', n_cycles=20, md_length=0.5, gpu_id=0, hmr=True, wqb_threshold=6)

# or drive single phases
structure, key_interaction = load_complex_pickle('complex_system.pickle')
sim = DuckSimulation(structure, key_interaction, gpu_id=0, hmr=True)
sim.load_checkpoint('equil.chk')
sim.run_md(0.5, csv_file='md.csv')
work_profile = sim.run_smd(300, 'smd_300.dat', start_dist=2.5, speed=0.005)  # numpy array (r0, r, force, work)

The analysis functions (duck.utils.analysis_and_report, duck.utils.crooks), the restraint builders (duck.utils.duck_stuff), the preparation (duck.steps.parametrize, duck.steps.chunk) and the AMBER templates (duck.utils.amber_inputs) can be used in the same way to build new protocols. DuckSimulation.run_smd steers in both directions (negative distance) with an optional per-run spring_k, and run_hold, reassign_velocities and current_distance cover the usual protocol steps. examples/custom_protocol.py writes the forward/reverse protocol in ~40 lines, and duck.steps.bidirectional is the full version behind openduck-crooks.

Changes in 0.3

See CHANGELOG.md. The OpenMM production was rewritten to reproduce the AMBER protocol and to run ~20 times faster; OpenMM results are therefore not directly comparable with those of OpenDUck ≤ 0.2, which used a spring half as stiff as AMBER's, a steering anchor updated every 400 fs that pulled only the ligand atom, restrained Na+/Cl- ions, chunk restraints referenced to the pre-minimisation coordinates and, with HMR, half the steering speed at 300 K.

Tested platforms

OpenDUck was tested on Linux x86-64 (Ubuntu 24.04 under WSL2, glibc 2.39, November 2026). Each row is a separate conda-forge environment, in which two test sets were run on the CPU:

  • unit tests: python -m pytest tests, 104 tests, including the preparation of a solvated complex with GAFF2 and SMIRNOFF ligand parameters;
  • end-to-end test: ./test.sh DATA_DIR, with chunking, amber-prepare, openmm-full-protocol, openmm-from-equilibrated and report.
Python OpenMM AmberTools openff-toolkit openmmforcefields RDKit NumPy Unit tests test.sh
3.9 (environment-py39.yaml) 7.5.1 22.0 0.9.0 0.9.0 2023.03.3 1.23.5 passed passed
3.9 8.3.1 22.5 0.16.5 0.12.0 2023.03.3 1.26.4 passed passed
3.101 8.6.0 24.8 0.16.10 0.14.2 2025.03.6 2.2.6 passed passed
3.11 8.6.1 26.0 0.18.0 0.16.0 2026.03.1 2.4.6 passed passed
3.12 8.6.1 26.0 0.19.0 0.16.0 2026.03.1 2.5.4 passed passed
3.13 8.6.1 26.0 0.19.0 0.16.0 2026.03.1 2.5.4 passed passed
3.14 (environment.yaml) 8.6.1 26.0 0.19.0 0.16.0 2026.09.1 2.5.4 passed passed

1 With setuptools<81. With Python 3.10, conda installs openff-amber-ff-ports 0.0.4, which imports pkg_resources; setuptools 81 removed it, so SMIRNOFF parametrization fails without the pin.

The unit tests were also run inside other Linux distributions. The environment was mounted into containers of older distributions so that its programs used their glibc, and fresh containers were built from openDUck_singularity.def:

Distribution glibc environment-py39.yaml environment.yaml
CentOS 7 2.17 passed passed
Rocky Linux 8 2.28 passed passed
Ubuntu 20.04 2.31 passed passed
Rocky Linux 9 2.34 passed, as a container build not tested
Ubuntu 24.04 2.39 passed passed, also as a container build

Other systems:

  • macOS (Intel and Apple Silicon): environment.yaml can be installed on macOS 13.3 or newer (checked with the conda solver), but OpenDUck has not been run on macOS. There is no CUDA on macOS; without -g, OpenMM runs on the CPU. environment-py39.yaml is Linux only.
  • Windows: conda-forge has no AmberTools for Windows, so use WSL2. The tests above ran under WSL2.
  • GPU: the tests above ran on the CPU. The GPU (CUDA) runs, including the performance figures above, used environment-py39.yaml on an RTX 3070.

The same topology and coordinates give the same energy in OpenMM 7.5.1 and 8.6.1, term by term to 10-6 kcal/mol. The AM1-BCC charges of a ligand, however, can differ by up to 0.06 e between RDKit versions, because openff-toolkit computes them on a conformer generated by RDKit rather than on the input pose. environment-py39.yaml reproduces the charges of the published validation.

About

Open-source DUck (Dynamic Undocking)

Resources

Stars

13 stars

Watchers

1 watching

Forks

Releases

Packages

Used by

Contributors

Languages