OpenMMDL

https://github.com/wolberlab/openmmdl
Admin
OpenMMDL is an interface for easy setup, simulation, and analysis of molecular dynamics simulations...
Tokens:40,463
Snippets:258
Trust Score:6.6
License:MIT
Update:9 months ago
Show doc for...
Tokens:
Raw
### Start OpenMMDL Setup

Source: https://github.com/wolberlab/openmmdl/blob/main/README.md

Launches the OpenMMDL Setup interface, which prepares input files for MD simulations. The interface is accessed via a web browser pointing to the address displayed in the console.

```bash
openmmdl_setup
```

--------------------------------

### Launch OpenMMDL Setup Web Interface

Source: https://context7.com/wolberlab/openmmdl/llms.txt

Launches the web-based interface for preparing molecular dynamics simulation input files. It guides users through uploading structures, selecting force fields, and configuring the simulation environment, outputting processed PDB and simulation scripts.

```bash
openmmdl_setup

# The interface opens in browser at http://127.0.0.1:5000
# Workflow:
# 1. Upload PDB file and optionally SDF ligand file
# 2. Select force field (e.g., amber14, charmm36) and water model
# 3. Choose chains to include, add missing residues/atoms
# 4. Add solvent box or membrane environment
# 5. Download processed PDB and simulation script

# Alternative: Generate Amber topology files using bash script
# For systems requiring AmberTools preparation:
# The setup generates a bash script that can be executed:
bash run_ambertools.sh

# Example output files:
# - processed_protein.pdb (cleaned topology)
# - OpenMMDL_Simulation.py (simulation script)
# - system.prmtop, system.inpcrd (for Amber workflows)
```

--------------------------------

### Initiate OpenMMDL Visualization

Source: https://github.com/wolberlab/openmmdl/blob/main/README.md

This command starts the OpenMMDL visualization process. It allows users to specify the visualization software, with 'nglview' as the default. Upon execution, it either opens a Jupyter notebook for NGLView integration or generates a Python script for PyMOL visualization, guiding the user through the visualization steps.

```bash
openmmdl_visualization
```

--------------------------------

### OpenMMDL Simulation Test Case 1 (6B73)

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/openmmdl_simulation.md

Provides the specific command to run a test simulation for the 6B73 protein-ligand complex. This example includes details for a POPC membrane and TIP3P-FB water system, essential for verifying OpenMMDL's functionality with complex setups.

```bash
openmmdl_simulation -f 6b73_testing_simulation -t ~/OpenMMDL/openmmdl_simulation/testing_sytems/6b73_membrane/6b73-moe-processed_openMMDL.pdb -s ~/OpenMMDL/openmmdl_simulation/testing_sytems/6b73_membrane/6b73_simulation.py -l  ~/OpenMMDL/openmmdl_simulation/testing_sytems/6b73_membrane/6b73_lig.sdf
```

--------------------------------

### Run OpenMMDL Simulation using SLURM (runOpenMM_slurm.sh)

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/openmmdl_simulation.md

Illustrates how to initiate OpenMMDL simulations using the SLURM workload manager via the runOpenMM_slurm.sh script. This includes basic usage and an example for running multiple replicas with specified input and output configurations.

```bash
bash runOpenMM_slurm.sh
```

```bash
bash runOpenMM.sh -i /path/to/Input/Folder -n 5 -c
```

--------------------------------

### OpenMMDL Simulation Test Case 2 (5WYZ)

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/openmmdl_simulation.md

Details the command for executing a test simulation of the 5WYZ protein-ligand complex with TIP3P water. This example is crucial for testing OpenMMDL's performance and output with simpler solvent environments.

```bash
openmmdl_simulation -f 5wyz_testing_simulation -t ~/OpenMMDL/openmmdl_simulation/testing_sytems/5wyz_solvent/5wyz-moe-processed_openMMDL.pdb -s ~/OpenMMDL/openmmdl_simulation/testing_sytems/5wyz_solvent/5wyz_simulation.py -l  ~/OpenMMDL/openmmdl_simulation/testing_sytems/5wyz_solvent/5VF.sdf
```

--------------------------------

### Clone OpenMMDL Repository

Source: https://github.com/wolberlab/openmmdl/blob/main/README.md

Clones the OpenMMDL source code from GitHub to your local machine. This is the first step for installing from the repository or building the Docker image.

```bash
cd ~
git clone https://github.com/wolberlab/OpenMMDL
```

--------------------------------

### Install OpenMMDL via Conda

Source: https://github.com/wolberlab/openmmdl/blob/main/README.md

Installs the OpenMMDL package from the conda-forge channel for Linux-based systems. This is a straightforward way to get started with OpenMMDL.

```bash
conda install -c conda-forge openmmdl
```

--------------------------------

### Install OpenMMDL Package with Pip

Source: https://github.com/wolberlab/openmmdl/blob/main/README.md

Installs the OpenMMDL package from the local source code using pip. This should be run after activating the Conda environment and navigating to the cloned repository.

```bash
pip install .
```

--------------------------------

### JavaScript: OpenMMDL Loading Spinner Animation

Source: https://github.com/wolberlab/openmmdl/blob/main/openmmdl/openmmdl_setup/templates/layout.html

This JavaScript code defines functions to animate a loading spinner and display a progress overlay. It manipulates DOM elements to create a visual indicator of ongoing processes. It requires HTML elements with specific IDs to function correctly.

```javascript
function submitWithSpinner(formName) {
  animateSpinner.animateIndex = 0;
  var parent = document.getElementById('progressParent');
  while (parent.firstChild) parent.removeChild(parent.firstChild);
  for (var i = 0; i < 12; i++) {
    var element = document.createElement('div');
    var angle = 30*i;
    var x = Math.round(Math.sin(i*Math.PI/6)*80+120);
    var y = Math.round(-Math.cos(i*Math.PI/6)*80);
    element.id = 'progress'+i;
    element.style = 'width:10px;height:80px;border-radius:5px;border:2px;position:absolute;transform:rotate('+angle+'deg);left:'+x+'px;top:'+y+'px';
    parent.appendChild(element);
  }
  setTimeout(function() {
    animateSpinner();
    document.getElementById('overlay').style.visibility='visible';
  }, 500);
  document.getElementById(formName).submit();
}

function animateSpinner() {
  for (var i = 0; i < 12; i++) {
    var bar = document.getElementById("progress"+i);
    if (i == animateSpinner.animateIndex)
      bar.style.backgroundColor = "black";
    else
      bar.style.backgroundColor = "lightgray";
  }
  animateSpinner.animateIndex = (animateSpinner.animateIndex+1)%12;
  setTimeout(function() {animateSpinner()}, 1000);
}
```

--------------------------------

### Run OpenMMDL Analysis with Default Parameters

Source: https://github.com/wolberlab/openmmdl/blob/main/README.md

This command initiates the OpenMMDL analysis. It requires mandatory inputs such as topology, trajectory, and ligand name. Optional arguments allow for customization of the analysis, including binding mode thresholds, CPU count, and specific analysis types like RMSD difference or stable water analysis. The default parameters are used when optional arguments are omitted.

```bash
openmmdl_analysis -t {path/to/topology} -d {path/to/trajectory} -n {Ligand_name}
```

--------------------------------

### OpenMMDL Simulation Command Line Usage

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/openmmdl_simulation.md

Demonstrates the basic command-line structure for initiating an OpenMMDL simulation, including mandatory and optional parameters. This is essential for setting up and running molecular dynamics simulations with OpenMMDL.

```bash
openmmdl_simulation -f {path/to/folder_name} -t {path/to/topology} -s {path/to/script} -l {path/to/ligand}
```

```bash
openmmdl_simulation -h all
```

--------------------------------

### Create Conda Environment for OpenMMDL

Source: https://github.com/wolberlab/openmmdl/blob/main/README.md

Creates a new Conda environment named 'openmmdl' and installs all required Python dependencies from the 'requirements.txt' file. This isolates OpenMMDL and its dependencies.

```bash
cd OpenMMDL
conda create -n openmmdl -c conda-forge --file requirements.txt
```

--------------------------------

### Calculate Minimum Transitions

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/modules/openmmdl_analysis/analysis/markovchains.md

Calculates a list based on the minimum transition time provided values and returns it in factors 1, 2, 5, 10.

```APIDOC
## GET /_calculate_min_transitions

### Description
Calculates a list based on the minimum transition time provided values and returns it in factors 1, 2, 5, 10.

### Method
GET

### Endpoint
/_calculate_min_transitions

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "example": "No request body needed for this endpoint."
}
```

### Response
#### Success Response (200)
- **transitions** (list) - List with the minimum transition time with factors 1, 2, 5, 10.

#### Response Example
```json
{
  "transitions": [0.1, 0.2, 0.5, 1.0]
}
```
```

--------------------------------

### Copy Slurm Script

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/tutorial_amber_path.md

Copies the Slurm run script to the tutorial directory. This script is used for running multiple MD replicas via Slurm. Configuration and environment paths within the script need to be updated.

```bash
copy run_slurm.sh openmmdl_amber_tutorial
```

--------------------------------

### Create Directory and Activate Environment - Shell

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/tutorial_pdb_path.md

Commands to create a new directory for simulation input files and activate the 'openmmdl' conda environment. This sets up the necessary workspace and environment for running OpenMMDL tools.

```shell
mkdir openmmdl_pdb_tutorial
conda activate openmmdl
```

--------------------------------

### _load_cloud Method

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/modules/openmmdl_analysis/visualization/visualization.md

Loads interaction clouds from a JSON file.

```APIDOC
## Method _load_cloud

### Description
Loads interaction clouds from a JSON file.

### Parameters
* **cloud_path** (*str*) - Path to the JSON file containing the interaction clouds.

### Returns
Dictionary representing different types of interaction clouds and their properties.

### Return type
dict
```

--------------------------------

### Run OpenMMDL Simulation Script

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/tutorial_amber_path.md

Initiates the molecular dynamics simulation using a Python script. This script requires pre-generated Prmtop and Inpcrd files.

```python
python3 OpenMMDL_Simulation.py
```

--------------------------------

### Initialize and Resize Script Container in JavaScript

Source: https://github.com/wolberlab/openmmdl/blob/main/openmmdl/openmmdl_setup/templates/simulationOptions.html

This code snippet configures the page by setting the initial script container size and ensures that the size is updated whenever the browser window is resized. It uses event listeners to manage these actions, providing a responsive layout for the script display area.

```javascript
// Configure the page based on initial values window.addEventListener("resize", updateScriptSize); updateScriptSize(); optionChanged(); {% endblock %}
```

--------------------------------

### Run OpenMMDL Simulation with Ligand

Source: https://github.com/wolberlab/openmmdl/blob/main/README.md

Executes an MD simulation using OpenMMDL, providing the necessary input files and optionally a ligand SDF file. This command requires specifying folder, topology, and script paths.

```bash
openmmdl_simulation -f {path/to/folder_name} -t {path/to/topology} -s {path/to/script} -l {path/to/ligand}
```

--------------------------------

### JavaScript: Initialize NGL Viewer and Load PDB Structure

Source: https://github.com/wolberlab/openmmdl/blob/main/openmmdl/openmmdl_setup/templates/selectChains.html

This JavaScript code initializes the NGL viewer upon DOMContentLoaded and loads the PDB structure from the provided URL. It then calls `optionChanged()` to set the initial state of the UI and the viewer, and centers the view on the loaded molecule.

```javascript
document.addEventListener( "DOMContentLoaded", function(){
  stage = new NGL.Stage("viewport");
  stage.loadFile("{{ url_for('getCurrentStructure') }}", {ext:"pdb"}).then(function(o) {
    molStructure = o;
    optionChanged();
    o.centerView();
  });
} );
```

--------------------------------

### Generate Transition Graph

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/modules/openmmdl_analysis/analysis/markovchains.md

Generates Markov chain graphs showing binding mode transitions across a simulation trajectory. Nodes represent binding modes, with size proportional to their frequency. Node colors reflect their dominant occurrence in one-third of the trajectory. Arrows represent transitions. Dual direction arrows show reversible behavior. For each transition threshold in min_transitions, a separate plot is generated and saved.

```APIDOC
## POST /generate_transition_graph

### Description
Generates Markov chain graphs showing binding mode transitions across a simulation trajectory. Nodes represent binding modes, with size proportional to their frequency. Node colors reflect their dominant occurrence in one-third of the trajectory. Arrows represent transitions. Dual direction arrows show reversible behavior. For each transition threshold in min_transitions, a separate plot is generated and saved.

### Method
POST

### Endpoint
/generate_transition_graph

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **total_frames** (int) - Required - The number of frames in the protein-ligand MD simulation.
- **combined_dict** (dict) - Required - A dictionary with the information of the Binding Modes and their order of appearance during the simulation for all frames.
- **fig_type** (str) - Optional - File type for the output figures. Default is ‘png’.
- **font_size** (int) - Optional - The font size for the node labels. The default value is set to 36.
- **size_node** (int) - Optional - The size of the nodes in the Markov Chain plot. The default value is set to 200.

### Request Example
```json
{
  "total_frames": 10000,
  "combined_dict": {
    "mode1": [0, 1, 5, 10, ...],
    "mode2": [2, 3, 6, 11, ...],
    "mode3": [4, 7, 8, 9, ...]
  },
  "fig_type": "pdf",
  "font_size": 24,
  "size_node": 300
}
```

### Response
#### Success Response (200)
None. Saves one plot per transition threshold in the directory Binding_Modes_Markov_States.

#### Response Example
```json
{
  "message": "Transition graphs generated successfully."
}
```
```

--------------------------------

### Initialize MDAnalysis and OS modules

Source: https://github.com/wolberlab/openmmdl/blob/main/openmmdl/openmmdl_simulation/scripts/test.ipynb

Imports necessary libraries, MDAnalysis for molecular dynamics analysis and os for operating system interactions. These are fundamental for file handling and data processing within the project.

```python
import MDAnalysis as mda
import os
```

--------------------------------

### Load PDB and Select/Write Topology Data with MDAnalysis

Source: https://github.com/wolberlab/openmmdl/blob/main/openmmdl/openmmdl_simulation/scripts/test.ipynb

Initializes an MDAnalysis Universe object with the specified PDB file. It then selects atoms based on a protein or a specified residue name (ligand). Finally, the selected atoms are written to a new PDB file named 'output.pdb'. Note: This snippet assumes 'ligName' would be defined elsewhere if specific ligand selection is needed.

```python
topo = mda.Universe (pdbfile)

topo_select = topo.select_atoms(f"protein or resname {ligName}")

topo_select.write(f"output.pdb")
```

--------------------------------

### Initialize OpenMMDL Visualizer with MDAnalysis Universe

Source: https://github.com/wolberlab/openmmdl/blob/main/openmmdl/openmmdl_analysis/visualization/visualization.ipynb

This snippet initializes the OpenMMDL Visualizer. It requires an MDAnalysis Universe object created from PDB and DCD files, a path to a clouds JSON file, and the ligand name. The 'special' parameter can be used for specific ligand types like HEM.

```python
from openmmdl.openmmdl_analysis.visualization.visualization import Visualizer
import MDAnalysis as mda
import os

ligname = 'UNK' # add the name of the ligand from the original PDB File
special = None # if special ligand like HEM is present add the name of the special ligand from the original PDB File
md = mda.Universe('PATH_TO_interacting_waters.pdb', 'PATH_TO_interacting_waters.dcd')
cloud = 'PATH_TO_clouds.json'

visualizer = Visualizer(md, cloud, ligname, special)
```

--------------------------------

### Jinja2: HTML Form for Input File Selection

Source: https://github.com/wolberlab/openmmdl/blob/main/openmmdl/openmmdl_setup/templates/configurePdbFile.html

This Jinja2 template section defines the HTML form for selecting input files and simulation parameters. It uses the `fileinput` macro for file uploads and presents options for force field, water model, ligand SDF file, and ligand processing.

```jinja2
{% extends "layout.html" %} {% macro fileinput(id) %}
<input type="file" id="{{ id }}" style="display:none" onchange="optionChanged()">
<label for="{{ id }}" class="btn btn-primary">Browse...</label>
<span id="{{ id }}_label"></span>
{% endmacro %}

{% block title %}Select Input Files{% endblock %}
{% block body %}
Select the pdb input file and options for how to model it.

PDB File

{{ fileinput('file') }}

Force Field

AMBER19 AMBER14 AMBER99SB AMBER99SB-ILDN AMBER03 AMBER10 CHARMM36 CHARMM36 2024

Water Model

Optional : Add ligand SDF file to the MD simulation (Default: No ligand)

Ligand File

{{fileinput('sdfFile') }}

Small Molecule Force Field

GAFF SMIRNOFF

Ligand Minimization

No Yes

Ligand Sanitization

No Yes

  
{% endblock %}
```

--------------------------------

### Build OpenMMDL Docker Image

Source: https://github.com/wolberlab/openmmdl/blob/main/README.md

Builds a Docker image for OpenMMDL, primarily useful for Windows and MacOS users or for creating a consistent Linux environment. It clones the repository and then uses `docker build`.

```bash
cd ~
git clone https://github.com/wolberlab/OpenMMDL
cd OpenMMDL
docker build -t openmmdl_env .
```

--------------------------------

### visualize Method

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/modules/openmmdl_analysis/visualization/visualization.md

Generates visualization of the trajectory with the interacting waters and interaction clouds.

```APIDOC
## Method visualize

### Description
Generates visualization of the trajectory with the interacting waters and interaction clouds.

### Parameters
* **receptor_type** (*str*) - Type of receptor. Defaults to ‘protein or nucleic’.
* **height** (*str*) - Height of the visualization. Defaults to ‘1000px’.
* **width** (*str*) - Width of the visualization. Defaults to ‘1000px’.

### Returns
Returns an nglview.widget object containing the visualization.

### Return type
nglview.NGLWidget
```

--------------------------------

### Load MDAnalysis Universe from PDB Files

Source: https://github.com/wolberlab/openmmdl/blob/main/openmmdl/openmmdl_analysis/visualization/visualization.ipynb

This snippet demonstrates how to load an MDAnalysis Universe object by checking for the existence of 'prot_lig.pdb' or 'centered_top.pdb' files. This is a common pattern for preparing molecular data for analysis or visualization.

```python
if os.path.exists("prot_lig.pdb"):
    u = mda.Universe("prot_lig.pdb")
elif os.path.exists("centered_top.pdb"):
    u = mda.Universe("centered_top.pdb")
```

--------------------------------

### Run Basic Molecular Dynamics Simulation

Source: https://context7.com/wolberlab/openmmdl/llms.txt

Executes a molecular dynamics simulation using prepared topology and configuration scripts. It supports both PDB topology with ligand SDF files and Amber topology/coordinate files, automatically handling energy minimization, equilibration, and production MD.

```bash
# Basic simulation with PDB topology and ligand
openmmdl_simulation \
  -f simulation_output \
  -t protein_processed.pdb \
  -s OpenMMDL_Simulation.py \
  -l ligand.sdf

# Simulation with Amber topology files
openmmdl_simulation \
  -f amber_simulation \
  -t system.prmtop \
  -c system.inpcrd \
  -s OpenMMDL_Simulation.py \
  -l ligand.sdf

# The simulation script automatically:
# - Performs energy minimization
# - Runs equilibration (default 0.5 ns)
# - Executes production MD (default 50 ns)
# - Outputs trajectory.dcd and topology files
# - Generates checkpoint files for restart capability

# Example simulation parameters in generated script:
# - Temperature: 300 K (Langevin integrator)
# - Pressure: 1 atm (NPT ensemble)
# - Timestep: 2 fs with hydrogen mass repartitioning
# - Force field: Amber14 or CHARMM36
# - Water model: TIP3P, OPC, or others
# - Platform: CUDA for GPU acceleration

# Output files:
# - trajectory.dcd (binary trajectory)
# - output_protein.pdb (multi-frame PDB)
# - log.txt (energy and temperature data)
# - checkpoint.chk (restart file)
```

--------------------------------

### Initialize MDonatello for 2D Molecule Visualization

Source: https://github.com/wolberlab/openmmdl/blob/main/openmmdl/openmmdl_analysis/visualization/visualization.ipynb

This snippet shows the import statement for the MDonatello library, which is used for 2D molecule visualization.

```python
import mdonatello
```

--------------------------------

### Define File Paths and Filenames for PDB

Source: https://github.com/wolberlab/openmmdl/blob/main/openmmdl/openmmdl_simulation/scripts/test.ipynb

Sets up the base directory path and the specific filename for a PDB (Protein Data Bank) file. It then constructs the full file path using os.path.join, ensuring cross-platform compatibility. A variable for ligand name is initialized to None.

```python
file_path = '/home/yuchen/or/OpenMMDL/8efo/env_openmm'
filename = 'comp.pdb'

pdbfile = os.path.join(file_path, filename)
ligName = None
```

--------------------------------

### Visualize OpenMMDL Interactions in PyMOL

Source: https://github.com/wolberlab/openmmdl/blob/main/README.md

This snippet demonstrates how to visualize OpenMMDL interaction data within the PyMOL molecular visualization software. It involves running a generated Python script and then using specific PyMOL console commands to load the interaction pointclouds and potentially interacting waters. This allows for detailed inspection of molecular interactions.

```python
run visualization_pymol.py
openmdl_visualization PATH_TO_interacting_waters.pdb, modulePATH_TO_clouds.json
```

--------------------------------

### Git Tagging for Versioning

Source: https://github.com/wolberlab/openmmdl/blob/main/devtools/README.md

Command to create an annotated Git tag for a specific commit and push it to the remote repository. This is used to mark releases and enable automated versioning.

```bash
git tag -a X.Y.Z [latest pushed commit] && git push --follow-tags
```

--------------------------------

### Visualize Molecular Dynamics Data with PyMOL and NGLView

Source: https://context7.com/wolberlab/openmmdl/llms.txt

Generates visualization files for interactive structure viewing of protein-ligand complexes and interactions. Supports PyMOL and NGLView (Jupyter) with options for different interaction types like hydrogen bonds and hydrophobic contacts.

```bash
# Generate visualization files
openmmdl_visualization --type pymol

# For PyMOL visualization:
# 1. Open PyMOL
# 2. Load the script:
run visualization_pymol.py
openmdl_visualization interacting_waters.pdb clouds.json

# For NGL view (Jupyter):
openmmdl_visualization --type nglview
# Opens Jupyter notebook with interactive viewer
```

--------------------------------

### run_visualization Function

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/modules/openmmdl_analysis/visualization/visualization.md

Runs the visualization notebook in the current directory.

```APIDOC
## Function run_visualization

### Description
Runs the visualization notebook in the current directory. The visualization notebook is copied from the package directory to the current directory and automatically started.

### Returns
None

### Return type
None
```

--------------------------------

### Markov Chain Analysis Class

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/modules/openmmdl_analysis/analysis/markovchains.md

Provides functionality to analyze the transitions of binding modes over time in MD simulations. It allows the generation of Markov chain plots based on transition probabilities between the binding modes and highlights key binding modes based on their occurency in the trajectory.

```APIDOC
## Class MarkovChainAnalysis

### Description
Class for analyzing binding mode transitions using Markov chains.

This class provides functionality to analyze the transitions of binding modes over time in MD simulations. It allows the generation of Markov chain plots based on transition probabilities between the binding modes and highlights key binding modes based on their occurency in the trajectory.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "example": "No request body needed for class instantiation."
}
```

### Response
#### Success Response (200)
- **min_transition** (float) - Minimum transition percentage threshold for transitions in the graph.
- **min_transitions** (list) - List of transition thresholds [x1, x2, x5, x10] derived from min_transition.

#### Response Example
```json
{
  "min_transition": 0.1,
  "min_transitions": [0.1, 0.2, 0.5, 1.0]
}
```
```

--------------------------------

### File Cleaning Procedures

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/openmmdl_simulation_functions.md

Functions for managing and cleaning simulation output files, including directory creation and file organization.

```APIDOC
## cleanup(protein_name)

### Description
Cleans up the PDB Reporter Output File and MDTraj Files of the performed simulation.

### Parameters
#### Path Parameters
- **protein_name** (str) - Required - Name of the protein PDB.

### Response
#### Success Response (200)
- **message** (str) - Indicates successful cleanup.

## create_directory_if_not_exists(directory_path)

### Description
Create a directory if it doesn’t exist, or overwrite it if already does.

### Parameters
#### Path Parameters
- **directory_path** (str) - Required - Path of the directory that you want to create.

### Response
#### Success Response (200)
- **message** (str) - Indicates successful directory creation or overwrite.

## copy_file(src, dest)

### Description
Copy a file to the destination path.

### Parameters
#### Path Parameters
- **src** (str) - Required - Path of the file that needs to be copied.
- **dest** (str) - Required - Path of destination where the file needs to be copied to.

### Response
#### Success Response (200)
- **message** (str) - Indicates successful file copy.

## organize_files(source, destination)

### Description
Organizes the files and moves them from the source to the destination directory.

### Parameters
#### Path Parameters
- **source** (str) - Required - Path of the file that needs to be moved.
- **destination** (str) - Required - Path of destination where the file needs to be moved to.

### Response
#### Success Response (200)
- **message** (str) - Indicates successful file organization and movement.

## post_md_file_movement(protein_name, prmtop=None, inpcrd=None, ligands=None)

### Description
Organizes and moves the files after the MD simulation to their respective directories.

### Parameters
#### Request Body
- **protein_name** (str) - Required - Name of the protein PDB.
- **prmtop** (str) - Optional - Path to the AMBER topology file.
- **inpcrd** (str) - Optional - Path to the AMBER coordinate file.
- **ligands** (List[str]) - Optional - List of paths to the ligand files.

### Response
#### Success Response (200)
- **message** (str) - Indicates successful post-MD file movement.
```

--------------------------------

### General Visualization API

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/api.md

Provides core visualization functionalities, including loading molecular data clouds and executing the visualization pipeline.

```APIDOC
## General Visualization API

### Description
This API encompasses the fundamental visualization capabilities of the OpenMMDL library. It includes methods for loading molecular data clouds and a top-level function to run the entire visualization process.

### Methods
- `Visualizer._load_cloud()`
- `Visualizer.visualize()`
- `run_visualization()`

### Endpoints
N/A (This appears to be a library/module-based API, not RESTful endpoints.)

### Parameters
N/A (Specific parameters depend on the individual methods and the `run_visualization` function.)

### Request Example
N/A

### Response
N/A
```

--------------------------------

### Initialize InteractionAnalyzer

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/modules/openmmdl_analysis/analysis/interactions.md

Initializes the InteractionAnalyzer class to analyze molecular interactions. It takes an MDAnalysis Universe object, an optional interaction CSV file path, the number of CPU processes to use, and details about the ligand and peptide for analysis.

```python
from openmmdl.interactions import InteractionAnalyzer
import MDAnalysis as mda

# Example initialization
# Assuming you have your topology and trajectory files
topology_file = 'path/to/your/topology.pdb'
trajectory_file = 'path/to/your/trajectory.xtc'

universe = mda.Universe(topology_file, trajectory_file)

interaction_analyzer = InteractionAnalyzer(
    pdb_md=universe,
    dataframe=None,  # Set to a file path if continuing analysis
    num_processes=4,  # Number of CPU cores
    lig_name='LIG',
    special_ligand=None, # e.g., 'MG'
    peptide='A',      # Chain ID of the peptide
    md_len=len(universe.trajectory) # Total number of frames
)
```

--------------------------------

### Configure Sphinx HTML Static Path

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/_templates/README.md

This snippet demonstrates how to configure the `html_static_path` setting in Sphinx's `conf.py` file. This path is used to specify directories containing static files, including custom HTML templates, that will be copied after the built-in ones. Ensure the path is relative to the `conf.py` file.

```python
html_static_path = ['_templates']
```

--------------------------------

### Initialize MoleculeVisualizer with MDAnalysis AtomGroup

Source: https://github.com/wolberlab/openmmdl/blob/main/openmmdl/openmmdl_analysis/visualization/visualization.ipynb

This snippet initializes the MoleculeVisualizer from MDonatello. It selects atoms belonging to the 'UNK' residue from an MDAnalysis Universe and configures visualization options such as showing atom indices and setting dimensions. Setting width and height to -1 indicates default sizing.

```python
ag = u.select_atoms("resname UNK")
visualizer = MoleculeVisualizer(ag, show_atom_indices=False, width=-1, height=-1)
```

--------------------------------

### StableWaters Class

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/modules/openmmdl_analysis/analysis/stablewaters.md

Initializes the StableWaters pipeline for identifying and analyzing stable water molecules from molecular dynamics (MD) trajectories.

```APIDOC
## StableWaters Class

### Description
A pipeline for identifying and analyzing stable water molecules from molecular dynamics (MD) trajectories.
This class processes MD simulations to trace water molecules that exhibit limited movement over time,
clusters them using DBSCAN and identifies representative water positions. Additionally, it analyzes
potential interactions between stable water clusters and protein residues.

### Parameters
* **trajectory** (*str*) – Path to the trajectory file.
* **topology** (*str*) – Path to the topology file.
* **water_eps** (*float*) – Epsilon parameter for DBSCAN clustering, in Angstrom.

### Variables
* **u** (*mda.Universe*) – Universe object created from the topology and trajectory files.
* **water_eps** (*float*) – Epsilon parameter for DBSCAN clustering, in Angstrom.
```

--------------------------------

### Submit Slurm Job

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/tutorial_amber_path.md

Submits the Slurm job to run the molecular dynamics simulation replicas. Ensure that Slurm configurations and OpenMMDL paths within 'run_slurm.sh' are correctly set.

```bash
sbatch run_slurm.sh
```

--------------------------------

### Run OpenMMDL Docker Container

Source: https://github.com/wolberlab/openmmdl/blob/main/README.md

Launches an interactive terminal within the OpenMMDL Docker container. This allows access to all OpenMMDL entry points and tools within the isolated environment.

```bash
docker run -it --name openmmdl_test openmmdl_env
```

--------------------------------

### Conditional Button Enable Logic

Source: https://github.com/wolberlab/openmmdl/blob/main/openmmdl/openmmdl_setup/templates/configureAmberFiles.html

This JavaScript code implements conditional logic to enable a 'continue' button based on the upload status of specific files (prmtop and inpcrd) and the selection of ligand types (nmLig and spLig). It checks for the presence of file values and selected ligand names to determine button interactivity.

```javascript
if (prmtopFileValue && inpcrdFileValue) { // if both nmLig and spLig are checked, the continue button will be enabled only if both nmLigName and spLigName are selected. if (nmLig && spLig) { continueButton.disabled = !(nmLigNameValue && spLigNameValue); } else if (nmLig) { // if the nmLig is checked, the continue button will be enabled only if the nmLigName is selected. continueButton.disabled = !nmLigNameValue; } else if (spLig) { // if the spLig is checked, the continue button will be enabled only if the spLigName is selected. continueButton.disabled = !spLigNameValue; } else { // if neither nmLig nor spLig is checked, enable the continue button continueButton.disabled = false; } } else { continueButton.disabled = true; }
```

--------------------------------

### Run Amber Tools Bash Script

Source: https://github.com/wolberlab/openmmdl/blob/main/docs/tutorial_amber_path.md

Executes a Bash script to generate Amber files. This script is typically generated based on user configurations in the Amber Configuration page. Error handling involves checking the 'leap.log' file.

```bash
bash run_ambertools.sh
```
Tokens:
Raw