Sync with development: Dockerfile (meeko, vina, openbabel, PYTHONPATH), amberflow package, .gitignore. Exclude Test/ (binary .ncrst not allowed on HF Hub).

.dockerignore

@@ -0,0 +1,54 @@
+# Git
+.git
+.gitignore
+
+# Python
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info
+dist
+build
+.pytest_cache
+.coverage
+htmlcov
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Output and temporary files
+output/
+temp/
+*.log
+*.tmp
+
+# Documentation
+*.md
+!README.md
+
+# Docker
+Dockerfile
+docker-compose.yml
+.dockerignore
+
+# Other
+*.bak
+*.backup
+

.gitignore

@@ -0,0 +1,61 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Project specific
+output/
+*.log
+*.tmp
+temp/
+
+# PDB files (optional - remove if you want to include example PDBs)
+*.pdb
+*.ent
+
+# AMBER files
+*.prmtop
+*.inpcrd
+*.rst
+*.rst7
+*.ncrst
+*.mdcrd
+*.nc
+*.dcd
+*.xtc
+*.trr
+
+# Test data (local only; binaries not allowed on HF Hub)
+Test/

Dockerfile

@@ -34,13 +34,14 @@ RUN conda tos accept --override-channels --channel https://repo.anaconda.com/pkg
 # Install mamba for faster package installation
 RUN conda install -n base -c conda-forge mamba -y
 
-# Install AMBER tools and PyMOL using mamba with Python 3.11 (compatible version)
-RUN mamba install -y python=3.11 conda-forge::ambertools conda-forge::pymol-open-source
+# Install AMBER tools, PyMOL, AutoDock Vina, and Open Babel (for docking)
+RUN mamba install -y python=3.11 conda-forge::ambertools conda-forge::pymol-open-source \
+    conda-forge::autodock-vina conda-forge::openbabel
 
 # Clean up conda/mamba cache to reduce image size
 RUN conda clean -afy
 
-# Install Python packages via pip
+# Install Python packages via pip (AmberFlow deps: Dockerfile minus scipy, plus meeko for docking)
 RUN pip install --no-cache-dir \
     flask==2.3.3 \
     flask-cors==4.0.0 \
@@ -53,7 +54,7 @@ RUN pip install --no-cache-dir \
     gunicorn==21.2.0 \
     requests==2.31.0 \
     rdkit==2023.3.1 \
-    scipy==1.11.1
+    meeko>=0.7.0
 
 # Set working directory
 WORKDIR /AmberFlow
@@ -65,12 +66,11 @@ COPY . .
 RUN mkdir -p /AmberFlow/obsolete /AmberFlow/pdb /AmberFlow/temp /AmberFlow/output && \
     chmod -R 777 /AmberFlow
 
-# Make sure the python directory is in the Python path
-ENV PYTHONPATH="${PYTHONPATH}:/AmberFlow/python"
+# Make sure the amberflow package is on the Python path
+ENV PYTHONPATH="${PYTHONPATH}:/AmberFlow"
 
 # Expose the port
 EXPOSE 7860
 
 # Run the application
 CMD ["python", "start_web_server.py"]
-

README.md

@@ -1,124 +1,295 @@
+# AmberFlow
+
+**AmberFlow** is a web-based pipeline for preparing structures, setting up molecular dynamics (MD) simulations with the AMBER force field. It integrates structure completion (ESMFold), preparation, force field parameterization, simulation file generation, and PLUMED-based biased MD in a single interface.
+
 ---
-title: AmberFlow - MD Simulation Pipeline
-emoji: 🧬
-colorFrom: blue
-colorTo: purple
-sdk: docker
-pinned: false
-license: mit
-app_port: 7860
+
+## Features
+
+| Section | Description |
+|--------|-------------|
+| **Protein Loading** | Upload PDB files or fetch from RCSB PDB; 3D visualization with NGL |
+| **Fill Missing Residues** | Detect missing residues (RCSB annotations), complete with ESMFold, optional trimming and energy minimization of predicted structure|
+| **Structure Preparation** | Remove water/ions/H; add ACE/NME capping; chain and ligand selection; GAFF/GAFF2 parameterization |
+| **Ligand Docking** | AutoDock Vina + Meeko; configurable search box; pose selection and use selected ligand pose to setup MD simulations |
+| **Simulation Parameters** | Force fields (ff14SB, ff19SB), water models (TIP3P, SPCE), box size, temperature, pressure |
+| **Simulation Steps** | Restrained minimization, minimization, NVT, NPT, production — each with configurable parameters |
+| **Generate Files** | AMBER `.in` files, `prmtop`/`inpcrd`, PBS submission scripts |
+| **PLUMED** | Collective variables (PLUMED v2.9), `plumed.dat` editor, and simulation file generation with PLUMED |
+
 ---
 
-# AmberFlow - Molecular Dynamics Simulation Pipeline
+## Requirements for Custom PDB Files
 
-🧬 **AmberFlow** is a comprehensive web-based pipeline for preparing and setting up molecular dynamics (MD) simulations using the AMBER force field. This tool provides an intuitive interface for protein structure preparation, parameter generation, and simulation file creation.
+For **custom PDB files** (uploaded or fetched), ensure:
 
-## Features
+| Requirement | Description |
+|-------------|-------------|
+| **Chain IDs** | Chain IDs must be clearly marked in the PDB (column 22). The pipeline uses them for chain selection, missing-residue filling, and structure preparation. |
+| **Ligands as HETATM** | All non-protein, non-water, non-ion molecules (e.g., cofactors, drugs) must be in **HETATM** records. The pipeline detects and lists only HETATM entities as ligands. |
+| **Standard amino acids** | AmberFlow supports **standard amino acids** only. Non-standard residues (e.g., MSE, HYP, SEC, non-canonical modifications) are not explicitly parameterized; pre-process or replace them before use if needed. |
+
+For RCSB structures, the pipeline parses the header and HETATM as provided; for your own PDBs, apply the above conventions.
+
+---
+
+## Installation
+
+### Option 1: Docker (recommended)
+
+```bash
+git clone https://github.com/your-org/AmberFlow.git
+cd AmberFlow
+docker build -t amberflow .
+docker run -p 7860:7860 amberflow
+```
+
+Open `http://localhost:7860` in your browser.
+
+### Option 2: Local (Conda + pip)
+
+1. **Conda environment** with AMBER tools, PyMOL, and Python 3.10–3.11:
+
+   ```bash
+   conda create -n amberflow python=3.11
+   conda activate amberflow
+   conda install -c conda-forge ambertools pymol-open-source
+   ```
+
+2. **Conda packages for docking** (Vina, Open Babel; Meeko is via pip):
+
+   ```bash
+   conda install -c conda-forge autodock-vina openbabel
+   ```
+
+3. **Python packages**:
+
+   ```bash
+   pip install -r requirements.txt
+   # or: pip install flask flask-cors biopython numpy pandas matplotlib seaborn mdanalysis gunicorn requests rdkit meeko vina
+   ```
+
+3. **Run the app**:
+
+   ```bash
+   python start_web_server.py
+   ```
+
+   The app listens on `http://0.0.0.0:7860` by default.
 
-### 🔬 Structure Preparation
-- **Protein Loading**: Upload PDB files or fetch from RCSB PDB database
-- **Structure Cleaning**: Remove water molecules, ions, and hydrogen atoms
-- **Capping Groups**: Add ACE (N-terminal) and NME (C-terminal) capping groups
-- **Ligand Handling**: Preserve and process ligands with automatic force field parameter generation
-- **3D Visualization**: Interactive molecular viewer using NGL
-
-### ⚙️ Simulation Parameters
-- **Force Fields**: Support for ff14SB and ff19SB protein force fields
-- **Water Models**: TIP3P and SPCE water models
-- **System Setup**: Configurable box size and ion addition
-- **Thermodynamics**: Temperature and pressure control
-
-### 📋 Simulation Steps
-- **Restrained Minimization**: Position-restrained energy minimization
-- **Minimization**: Full system energy minimization
-- **NPT Heating**: Temperature equilibration
-- **NPT Equilibration**: Pressure and temperature equilibration
-- **Production Run**: Configurable production MD simulation
-
-### 📁 File Generation
-- **AMBER Input Files**: Complete set of .in files for all simulation steps
-- **Force Field Parameters**: Generated .prmtop and .inpcrd files
-- **PBS Scripts**: HPC submission scripts
-- **Analysis Scripts**: Post-simulation analysis tools
+### Option 3: Install from PyPI (when published)
+
+```bash
+pip install amberflow
+# Requires: AMBER tools, PyMOL, AutoDock Vina, Open Babel (e.g. conda install -c conda-forge ambertools pymol-open-source autodock-vina openbabel)
+amberflow
+```
+
+See **[PACKAGING.md](PACKAGING.md)** for dependency list, build, and PyPI release steps.
+
+---
 
 ## Usage
 
-1. **Load Protein Structure**
-   - Upload a PDB file or enter a PDB ID to fetch from RCSB
-   - View 3D structure and basic information
-
-2. **Prepare Structure**
-   - Configure structure preparation options
-   - Remove unwanted components (water, ions, hydrogens)
-   - Add capping groups for termini
-   - Handle ligands if present
-
-3. **Set Simulation Parameters**
-   - Choose force field and water model
-   - Configure system parameters
-   - Set temperature and pressure
-
-4. **Configure Simulation Steps**
-   - Enable/disable simulation steps
-   - Set step-specific parameters
-   - Configure production run duration
-
-5. **Generate Files**
-   - Generate all simulation input files
-   - Download files as ZIP archive
-   - Preview generated files
-
-## Technical Details
-
-### Dependencies
-- **MDAnalysis**: Structure manipulation and analysis
-- **BioPython**: PDB file parsing
-- **Flask**: Web framework
-- **NGL Viewer**: 3D molecular visualization
-- **AMBER Tools**: Force field parameter generation
-
-### File Structure
+### 1. Protein Loading
+
+- **Upload**: Drag-and-drop or choose a `.pdb` / `.ent` file.
+- **Fetch**: Enter a 4-character PDB ID (e.g. `1CRN`) to download from RCSB.
+
+After loading, the **Protein Preview** shows: structure ID, atom count, chains, residues, water, ions, ligands, and HETATM count. Use the 3D viewer to inspect the structure.
+
+---
+
+### 2. Fill Missing Residues
+
+- Click **Analyze Missing Residues** to detect gaps from RCSB metadata.
+- **Select chains** to complete with ESMFold.
+- **Trim residues** (optional): remove residues from N- or C-terminal edges; internal loops are always filled by ESMFold.
+- **Energy minimization** (optional): if you enable ESMFold completion, you can minimize selected chains to resolve clashes before docking. Recommended if receptor preparation (Meeko) fails later.
+- **Build Completed Structure** to run ESMFold and (if requested) minimization. Use **Preview Completed Structure** and **View Superimposed Structures** to compare original and completed chains.
+
+> If you use ESMFold in this workflow, please cite [ESM Atlas](https://esmatlas.com/about).
+
+---
+
+### 3. Structure Preparation
+
+- **Remove**: Water, ions, and hydrogens (options are pre-configured).
+- **Add capping**: ACE (N-terminal) and NME (C-terminal).
+- **Chains**: Select which protein chains to keep for force field generation.
+- **Ligands**:
+  - **Preserve ligands** to keep them in the structure.
+  - **Select ligands to preserve** (e.g. `GOL-A-1`, `LIZ-A`). Unselected ligands are dropped.
+  - **Create separate ligand file** to export selected ligand(s) to a PDB.
+
+Click **Prepare Structure**. The status panel reports original vs prepared atom counts, removed components, added capping, and preserved ligands. Use **View Prepared Structure** and **Download Prepared PDB** as needed.
+
+**Ligand Docking** (nested in this tab):
+
+- Select ligands to dock.
+- Set the **search space** (center and size in X, Y, Z) with live 3D visualization.
+- **Run Docking** (AutoDock Vina + Meeko). Progress and logs are shown in the docking panel.
+- **Select poses** per ligand and **Use selected pose** to write the chosen pose into the structure for AMBER. You can switch modes (e.g. 1–9) and jump by clicking the mode labels.
+
+---
+
+### 4. Simulation Parameters
+
+- **Force field**: ff14SB or ff19SB.
+- **Water model**: TIP3P or SPCE.
+- **Box size** (Å): padding for solvation.
+- **Add ions**: to neutralize (and optionally reach a salt concentration).
+- **Temperature** and **Pressure** (e.g. 300 K, 1 bar).
+- **Time step** and **Cutoff** for non-bonded interactions.
+
+If ligands were preserved, **Ligand force field** (GAFF/GAFF2) is configured here; net charge is computed before `antechamber` runs.
+
+---
+
+### 5. Simulation Steps
+
+Enable/disable and set parameters for:
+
+- **Restrained minimization** (steps, force constant)
+- **Minimization** (steps, cutoff)
+- **NVT heating** (steps, temperature)
+- **NPT equilibration** (steps, temperature, pressure)
+- **Production** (steps, temperature, pressure)
+
+---
+
+### 6. Generate Files
+
+- **Generate All Files** to create AMBER inputs (`min_restrained.in`, `min.in`, `HeatNPT.in`, `mdin_equi.in`, `mdin_prod.in`), `tleap` scripts, `submit_job.pbs`, and (after `tleap`) `prmtop`/`inpcrd`.
+- **Preview Files** to open and **edit** each file (e.g. `min.in`, `submit_job.pbs`) and **Save**; changes are written to the output directory.
+- **Preview Solvated Protein** / **Download Solvated Protein** to inspect and download the solvated system.
+
+For **PLUMED-based runs**, go to the **PLUMED** tab to configure CVs and `plumed.dat`, then use **Generate simulation files** there to produce inputs that include PLUMED.
+
+---
+
+### 7. PLUMED
+
+- **Collective Variables**: search and select CVs from the PLUMED v2.9 set; view docs and add/edit lines in `plumed.dat`.
+- **Custom PLUMED**: edit `plumed.dat` directly.
+- **Generate simulation files**: create AMBER + PLUMED input files. Generated files can be **previewed, edited, and saved** as in the main **Generate Files** tab.
+
+> PLUMED citation: [plumed.org/cite](https://www.plumed.org/cite).
+
+---
+
+## Pipeline Overview
+
+```
+Protein Loading (upload/fetch)
+        ↓
+Fill Missing Residues (detect → ESMFold → optional trim & minimize)
+        ↓
+Structure Preparation (clean, cap, chains, ligands) → optional Docking (Vina, apply pose)
+        ↓
+Simulation Parameters (FF, water, box, T, P, etc.)
+        ↓
+Simulation Steps (min, NVT, NPT, prod)
+        ↓
+Generate Files (AMBER .in, tleap, prmtop/inpcrd, PBS)
+        ↓
+[Optional] PLUMED (CVs, plumed.dat, generate PLUMED-enabled files)
+```
+
+---
+
+## Output Layout
+
+Generated files are written under `output/` (or the path set in the app), for example:
+
+- `0_original_input.pdb` — raw input
+- `1_protein_no_hydrogens.pdb` — cleaned, capped, chain/ligand selection applied
+- `2_protein_with_caps.pdb`, `tleap_ready.pdb` — intermediates
+- `4_ligands_corrected_*.pdb` — prepared ligands
+- `protein.prmtop`, `protein.inpcrd` — after `tleap`
+- `min_restrained.in`, `min.in`, `HeatNPT.in`, `mdin_equi.in`, `mdin_prod.in`, `submit_job.pbs`
+- `output/docking/` — receptor, ligands, Vina configs, poses, logs
+- `plumed.dat` — when using PLUMED
+
+---
+
+## Dependencies
+
+| Category | Tools / libraries |
+|----------|-------------------|
+| **Python** | Flask, Flask-CORS, BioPython, NumPy, Pandas, Matplotlib, Seaborn, MDAnalysis, Requests, RDKit, SciPy |
+| **AMBER** | AMBER Tools (tleap, antechamber, sander, ambpdb, etc.) |
+| **Docking** | Meeko (`mk_prepare_ligand`, `mk_prepare_receptor`), AutoDock Vina, Open Babel |
+| **Visualization** | PyMOL (scripted for H removal, structure editing), NGL (in-browser 3D) |
+| **Structure completion** | ESMFold (via API or local, depending on deployment) |
+
+---
+
+## Project Structure
+
 ```
 AmberFlow/
-├── app.py                 # Hugging Face Spaces entry point
-├── requirements.txt       # Python dependencies
-├── python/
-│   ├── app.py            # Main Flask application
-│   ├── structure_preparation.py
-│   └── requirements.txt
+├── start_web_server.py      # Entry point
 ├── html/
-│   └── index.html        # Web interface
+│   ├── index.html           # Main UI
+│   └── plumed.html          # PLUMED-focused view (if used)
 ├── css/
-│   └── styles.css        # Styling
+│   ├── styles.css
+│   └── plumed.css
 ├── js/
-│   └── script.js         # Frontend logic
-├── templates/            # AMBER input file templates
-└── add_caps.py          # Capping group addition script
+│   ├── script.js            # Main frontend logic
+│   ├── plumed.js            # PLUMED + docking UI
+│   └── plumed_cv_docs.js    # CV documentation
+├── python/
+│   ├── app.py               # Flask backend, API, file generation
+│   ├── structure_preparation.py
+│   ├── add_caps.py          # ACE/NME capping
+│   ├── Fill_missing_residues.py  # ESMFold, trimming, minimization
+│   ├── docking.py           # Docking helpers
+│   └── docking_utils.py
+├── output/                  # Generated files (gitignored in dev)
+├── Dockerfile
+└── README.md
 ```
 
+---
+
 ## Citation
 
-If you use AmberFlow in your research, please cite:
+If you use AmberFlow in your work, please cite:
 
 ```bibtex
-@software{Amberflow2025,
-  title={AmberFlow: Molecular Dynamics Simulation Pipeline},
-  author={Hemant Nagar},
-  year={2025},
-  url={https://huggingface.co/spaces/hemantn/AmberFlow}
+@software{AmberFlow,
+  title = {AmberFlow: Molecular Dynamics and Docking Pipeline},
+  author = {Nagar, Hemant},
+  year = {2025},
+  url = {https://github.com/your-org/AmberFlow}
 }
 ```
 
+**Related software to cite when used:**
+
+- **AMBER**: [ambermd.org](https://ambermd.org)
+- **PLUMED**: [plumed.org/cite](https://www.plumed.org/cite)
+- **ESMFold / ESM Atlas**: [esmatlas.com/about](https://esmatlas.com/about)
+- **AutoDock Vina**: Trott & Olson, *J. Comput. Chem.* (2010)
+- **Meeko**: [github.com/forlilab/Meeko](https://github.com/forlilab/Meeko)
+
+---
+
 ## Acknowledgments
 
-- **Mohd Ibrahim** (Technical University of Munich) for the protein capping functionality (`add_caps.py`)
+- **Mohd Ibrahim** (Technical University of Munich) for the protein capping logic (`add_caps.py`).
+
+---
 
 ## License
 
-This project is licensed under the MIT License - see the LICENSE file for details.
+MIT License. See `LICENSE` for details.
+
+---
 
 ## Contact
 
-- **Author**: Hemant Nagar
+- **Author**: Hemant Nagar  
 - **Email**: hn533621@ohio.edu
-

SETUP_STEPS.md

@@ -0,0 +1,128 @@
+# AmberFlow_development Repository Setup Steps
+
+This document outlines all the steps taken to create the `AmberFlow_development` repository and sync files from the original `AmberFlow` repository.
+
+## Steps Performed
+
+### 1. Create New Folder
+```bash
+mkdir -p AmberFlow_development
+```
+Created a new directory called `AmberFlow_development` in the home directory (`/home/hn533621/`).
+
+### 2. Copy All Files from AmberFlow
+```bash
+cp -r AmberFlow/* AmberFlow_development/
+cp -r AmberFlow/.[!.]* AmberFlow_development/
+```
+Copied all files and hidden files (except `.` and `..`) from the `AmberFlow` directory to the new `AmberFlow_development` directory.
+
+**Files copied:**
+- `add_caps.py`
+- `css/` directory
+- `Dockerfile`
+- `.gitattributes`
+- `html/` directory
+- `js/` directory
+- `obsolete/` directory
+- `output/` directory
+- `python/` directory
+- `README.md`
+- `start_web_server.py`
+
+### 3. Remove Old Git Repository
+```bash
+rm -rf .git
+```
+Removed the existing `.git` directory from the copied files to start fresh with a new git repository.
+
+### 4. Create .gitignore File
+Created a `.gitignore` file to exclude unnecessary files from version control:
+
+**Contents:**
+- Python cache files (`__pycache__/`, `*.pyc`, etc.)
+- Output files (`output/`, `*.pdb`, `*.cif`, `*.log`)
+- IDE files (`.vscode/`, `.idea/`, etc.)
+- OS files (`.DS_Store`, `Thumbs.db`)
+- Environment files (`.env`, `venv/`, etc.)
+
+### 5. Initialize Git Repository
+```bash
+git init
+```
+Initialized a new empty git repository in the `AmberFlow_development` directory.
+
+### 6. Rename Branch to main
+```bash
+git branch -m main
+```
+Renamed the default branch from `master` to `main` to follow modern git conventions.
+
+### 7. Stage All Files
+```bash
+git add .
+```
+Staged all files in the repository for the initial commit.
+
+### 8. Create Initial Commit
+```bash
+git commit -m "Initial commit: Copy from AmberFlow"
+```
+Created the initial commit with all copied files.
+
+**Commit details:**
+- 11 files changed
+- 6,567 insertions
+- Files included: `.gitattributes`, `.gitignore`, `Dockerfile`, `README.md`, `add_caps.py`, CSS, HTML, JS files, Python application files, and `start_web_server.py`
+
+### 9. Create Private GitHub Repository
+```bash
+gh repo create AmberFlow_development --private --source=. --remote=origin --push
+```
+Created a private GitHub repository named `AmberFlow_development` and pushed all files.
+
+**Repository details:**
+- Repository URL: https://github.com/nagarh/AmberFlow_development
+- Visibility: Private
+- Remote name: `origin`
+- Branch: `main`
+
+### 10. Verify Setup
+```bash
+git remote -v
+git status
+```
+Verified that:
+- Remote `origin` is correctly configured to point to the GitHub repository
+- All files are committed and pushed
+- Working tree is clean
+
+## Summary
+
+The `AmberFlow_development` repository has been successfully created as a private GitHub repository with all files from the original `AmberFlow` directory. The repository is now ready for development work and version control.
+
+## Future Git Operations
+
+To make changes and push them to GitHub:
+
+1. **Stage changes:**
+   ```bash
+   git add .
+   ```
+
+2. **Commit changes:**
+   ```bash
+   git commit -m "Your commit message"
+   ```
+
+3. **Push to GitHub:**
+   ```bash
+   git push
+   ```
+
+## Notes
+
+- The original `AmberFlow` repository remains unchanged and still points to the Hugging Face Space
+- The new `AmberFlow_development` repository is completely independent
+- A `.gitignore` file has been added to exclude unnecessary files from version control
+

amberflow/Fill_missing_residues.py

@@ -0,0 +1,446 @@
+import requests
+from collections import defaultdict
+from textwrap import wrap
+import re
+
+
+def get_pdb_id_from_pdb_file(pdb_path):
+    """
+    Extract the 4-character PDB ID from a PDB file.
+
+    By convention, PDB files have a line starting with 'HEADER' where
+    columns 63–66 contain the PDB ID code.
+
+    If that cannot be found, this function will raise a ValueError so
+    that the pipeline fails loudly instead of silently doing the wrong thing.
+    """
+    with open(pdb_path, "r") as fh:
+        for line in fh:
+            if line.startswith("HEADER") and len(line) >= 66:
+                pdb_id = line[62:66].strip()
+                if pdb_id:
+                    return pdb_id.upper()
+
+    raise ValueError(
+        f"Could not determine PDB ID from file: {pdb_path}. "
+        "Expected a 'HEADER' record with ID in columns 63–66."
+    )
+
+GRAPHQL_URL = "https://data.rcsb.org/graphql"
+
+def detect_missing_residues(pdb_id):
+    url = f"https://files.rcsb.org/download/{pdb_id}.pdb"
+    response = requests.get(url)
+    response.raise_for_status()
+
+    missing_by_chain = defaultdict(list)
+
+    for line in response.text.splitlines():
+        if line.startswith("REMARK 465"):
+            parts = line.split()
+            if len(parts) >= 5 and parts[2].isalpha():
+                resname = parts[2]
+                chain = parts[3]
+
+                # Extract residue number (strip insertion code, handle negative numbers)
+                match = re.match(r"(-?\d+)", parts[4])
+                if match:
+                    resnum = int(match.group(1))
+                    missing_by_chain[chain].append((resname, resnum))
+
+    return dict(missing_by_chain)
+
+def get_chain_sequences(pdb_id):
+    query = """
+    query ChainSequences($pdb_id: String!) {
+      entry(entry_id: $pdb_id) {
+        polymer_entities {
+          entity_poly {
+            pdbx_seq_one_letter_code_can
+          }
+          polymer_entity_instances {
+            rcsb_polymer_entity_instance_container_identifiers {
+              auth_asym_id
+            }
+          }
+        }
+      }
+    }
+    """
+
+    r = requests.post(
+        GRAPHQL_URL,
+        json={"query": query, "variables": {"pdb_id": pdb_id}}
+    )
+    r.raise_for_status()
+
+    chain_seqs = {}
+
+    for entity in r.json()["data"]["entry"]["polymer_entities"]:
+        seq = entity["entity_poly"]["pdbx_seq_one_letter_code_can"]
+        for inst in entity["polymer_entity_instances"]:
+            chain = inst[
+                "rcsb_polymer_entity_instance_container_identifiers"
+            ]["auth_asym_id"]
+            chain_seqs[chain] = seq
+
+    return chain_seqs
+
+def trim_residues_from_edges(sequence, n_terminal_trim=0, c_terminal_trim=0):
+    """
+    Trim residues from the edges (N-terminal and C-terminal) of a sequence.
+    Only trims from the edges, not from loops in between.
+    
+    Args:
+        sequence: str
+            The amino acid sequence to trim
+        n_terminal_trim: int
+            Number of residues to remove from the N-terminal (start)
+        c_terminal_trim: int
+            Number of residues to remove from the C-terminal (end)
+    
+    Returns:
+        str: The trimmed sequence
+    
+    Raises:
+        ValueError: If trim counts exceed sequence length or are negative
+    """
+    if n_terminal_trim < 0 or c_terminal_trim < 0:
+        raise ValueError("Trim counts must be non-negative")
+    
+    if n_terminal_trim + c_terminal_trim >= len(sequence):
+        raise ValueError(
+            f"Total trim count ({n_terminal_trim + c_terminal_trim}) exceeds sequence length ({len(sequence)})"
+        )
+    
+    # Trim from N-terminal (start) and C-terminal (end)
+    trimmed = sequence[n_terminal_trim:len(sequence) - c_terminal_trim]
+    
+    return trimmed
+
+
+def trim_chains_sequences(chains_with_sequences, trim_specs):
+    """
+    Apply trimming to multiple chain sequences based on specifications.
+    
+    Args:
+        chains_with_sequences: dict
+            Dictionary mapping chain IDs to sequences
+            Example: {'A': 'MKTAYIAKQR...', 'B': 'MKTAYIAKQR...'}
+        trim_specs: dict
+            Dictionary mapping chain IDs to trim specifications
+            Each specification is a dict with 'n_terminal' and/or 'c_terminal' keys
+            Example: {'A': {'n_terminal': 5, 'c_terminal': 3}, 'B': {'n_terminal': 2}}
+    
+    Returns:
+        dict: Dictionary mapping chain IDs to trimmed sequences
+    """
+    trimmed_chains = {}
+    
+    for chain, sequence in chains_with_sequences.items():
+        if chain in trim_specs:
+            spec = trim_specs[chain]
+            n_term = spec.get('n_terminal', 0)
+            c_term = spec.get('c_terminal', 0)
+            
+            try:
+                trimmed_seq = trim_residues_from_edges(sequence, n_term, c_term)
+                trimmed_chains[chain] = trimmed_seq
+            except ValueError as e:
+                raise ValueError(f"Error trimming chain {chain}: {str(e)}")
+        else:
+            # No trimming specified for this chain, keep original
+            trimmed_chains[chain] = sequence
+    
+    return trimmed_chains
+
+
+def write_fasta_for_missing_chains(pdb_id, chains_with_missing, output_dir=None):
+    """
+    Write FASTA file for chains with missing residues.
+    
+    Args:
+        pdb_id: PDB identifier
+        chains_with_missing: Dictionary mapping chain IDs to sequences
+        output_dir: Optional output directory. If None, writes to current directory.
+    """
+    filename = f"{pdb_id}_chains_with_missing.fasta"
+    
+    if output_dir:
+        from pathlib import Path
+        output_path = Path(output_dir) / filename
+    else:
+        output_path = filename
+
+    with open(output_path, "w") as f:
+        for chain, seq in chains_with_missing.items():
+            f.write(f">{pdb_id.upper()}_{chain}\n")
+            for line in wrap(seq, 60):
+                f.write(line + "\n")
+
+    print(f"Wrote FASTA: {output_path}")
+
+def run_esmfold(sequence):
+    response = requests.post(
+        "https://api.esmatlas.com/foldSequence/v1/pdb/",
+        data=sequence,
+        timeout=300
+    )
+    response.raise_for_status()
+    return response.text
+
+
+def merge_non_protein_atoms(original_pdb_path, protein_pdb_path, output_pdb_path, chains_to_replace):
+    """
+    Add non-protein atoms (water, ions, ligands) from original file to the completed protein structure.
+    
+    Parameters:
+    -----------
+    original_pdb_path : str
+        Path to the original PDB file
+    protein_pdb_path : str
+        Path to the temporary protein-only PDB file
+    output_pdb_path : str
+        Path where the final merged PDB will be written
+    chains_to_replace : list[str]
+        List of chain IDs that were replaced by ESMFold (not used, kept for compatibility)
+    """
+    import os
+    
+    # Extract non-protein atoms (HETATM records) from original PDB
+    non_protein_atoms = []
+    
+    if not os.path.exists(original_pdb_path):
+        print(f"Warning: Original PDB file not found: {original_pdb_path}")
+        # Just copy the protein file if original doesn't exist
+        if os.path.exists(protein_pdb_path):
+            import shutil
+            shutil.copy2(protein_pdb_path, output_pdb_path)
+        return
+    
+    # Read HETATM records from original PDB
+    with open(original_pdb_path, 'r') as f:
+        for line in f:
+            if line.startswith('HETATM'):
+                # Include all HETATM records (water, ions, ligands)
+                non_protein_atoms.append(line)
+    
+    # Read the completed protein structure
+    if not os.path.exists(protein_pdb_path):
+        print(f"Error: Protein PDB file not found: {protein_pdb_path}")
+        return
+    
+    # Write merged PDB file: protein structure + non-protein atoms
+    with open(output_pdb_path, 'w') as f:
+        # Write the completed protein structure (all lines except END)
+        with open(protein_pdb_path, 'r') as protein_file:
+            for line in protein_file:
+                if not line.startswith('END'):
+                    f.write(line)
+        
+        # Add non-protein atoms (water, ions, ligands) from original
+        for line in non_protein_atoms:
+            f.write(line)
+        
+        # Write END record at the very end
+        f.write("END                                                                             \n")
+    
+    print(f"✅ Added {len(non_protein_atoms)} non-protein atoms to completed structure")
+
+
+def rebuild_pdb_with_esmfold(
+    pdb_id,
+    chains_to_replace,
+    output_pdb=None,
+    original_pdb_path=None,
+    chains_use_minimized=None,
+):
+    """
+    pdb_id: str
+        Original crystal structure object name (e.g. '3hhr')
+
+    chains_to_replace: list[str]
+        Chains that were missing residues and replaced by ESMFold
+        Example: ['A', 'B', 'C']
+
+    output_pdb: str, optional
+        Output PDB filename.
+
+    original_pdb_path: str, optional
+        Path to the original PDB file that should be loaded into PyMOL
+        as the reference object named `pdb_id`. If None, defaults to
+        '../../output/0_original_input.pdb'.
+
+    chains_use_minimized: list[str], optional
+        For these chains, load the superimposed minimized PDB
+        ({pdb_id}_chain_{c}_esmfold_minimized_noH.pdb) instead of the
+        ESMFold PDB. The minimized structure is aligned to the original
+        the same way as ESMFold (CA-based superimposition).
+    """
+
+    from pymol import cmd
+
+    # -----------------------------
+    # 0. Clean up any existing objects with the same names
+    # -----------------------------
+    try:
+        # Delete existing objects if they exist
+        existing_objects = cmd.get_object_list()
+        if pdb_id in existing_objects:
+            cmd.delete(pdb_id)
+        
+        # Delete any existing ESMFold objects for the chains we're processing
+        for chain in chains_to_replace:
+            esm_obj = f"{pdb_id}_chain_{chain}_esmfold"
+            if esm_obj in existing_objects:
+                cmd.delete(esm_obj)
+        
+        # Delete final_model if it exists
+        if "final_model" in existing_objects:
+            cmd.delete("final_model")
+    except Exception as e:
+        print(f"Warning: Could not clean up existing objects: {e}")
+
+    # -----------------------------
+    # 1. Load original PDB into PyMOL
+    # -----------------------------
+    if original_pdb_path is None:
+        # Default to the pipeline output location
+        original_pdb_path = "../../output/0_original_input.pdb"
+
+    print(f"Loading original PDB from {original_pdb_path} as object '{pdb_id}'")
+    cmd.load(original_pdb_path, pdb_id)
+
+    if output_pdb is None:
+        output_pdb = f"{pdb_id}_rebuilt.pdb"
+
+    # -----------------------------
+    # 2. Align each ESMFold (or minimized) chain and fix chain IDs
+    # -----------------------------
+    for chain in chains_to_replace:
+        esm_obj = f"{pdb_id}_chain_{chain}_esmfold"
+
+        # For minimized chains, use the superimposed minimized noH PDB
+        # (minimization writes in a different frame; we align it to original here).
+        if chains_use_minimized and chain in chains_use_minimized:
+            esm_pdb_filename = f"{pdb_id}_chain_{chain}_esmfold_minimized_noH.pdb"
+            print(f"Loading minimized PDB {esm_pdb_filename} as object '{esm_obj}' (will superimpose to original)")
+        else:
+            esm_pdb_filename = f"{pdb_id}_chain_{chain}_esmfold.pdb"
+            print(f"Loading ESMFold PDB {esm_pdb_filename} as object '{esm_obj}'")
+        cmd.load(esm_pdb_filename, esm_obj)
+
+        # ESMFold outputs everything as chain A by default.
+        # Rename the chain in the loaded object to match the target chain ID.
+        print(f"Renaming chain A -> {chain} in {esm_obj}")
+        cmd.alter(esm_obj, f"chain='{chain}'")
+        cmd.sort(esm_obj)  # Rebuild internal indices after alter
+
+        align_cmd = (
+            f"{esm_obj} and name CA",
+            f"{pdb_id} and chain {chain} and name CA"
+        )
+
+        print(f"Aligning {esm_obj} to {pdb_id} chain {chain}")
+        cmd.align(*align_cmd)
+
+    # -----------------------------
+    # 3. Build selection strings
+    # -----------------------------
+    chains_str = "+".join(chains_to_replace)
+
+    esm_objs_str = " or ".join(
+        f"{pdb_id}_chain_{chain}_esmfold"
+        for chain in chains_to_replace
+    )
+
+    selection = (
+        f"({pdb_id} and not chain {chains_str}) or "
+        f"({esm_objs_str})"
+    )
+
+    # -----------------------------
+    # 4. Create final model
+    # -----------------------------
+    cmd.select("final_model", selection)
+
+    # -----------------------------
+    # 5. Save rebuilt structure (protein only)
+    # -----------------------------
+    import os
+    temp_protein_pdb = output_pdb.replace('.pdb', '_protein_temp.pdb')
+    cmd.save(temp_protein_pdb, "final_model")
+    
+    # -----------------------------
+    # 6. Add non-protein atoms from original PDB
+    # -----------------------------
+    print(f"Adding non-protein atoms from original file...")
+    # Convert paths to absolute paths if they're relative
+    abs_original = os.path.abspath(original_pdb_path) if original_pdb_path else None
+    abs_temp = os.path.abspath(temp_protein_pdb)
+    abs_output = os.path.abspath(output_pdb)
+    merge_non_protein_atoms(abs_original, abs_temp, abs_output, chains_to_replace)
+    
+    # Clean up temporary protein file
+    try:
+        if os.path.exists(temp_protein_pdb):
+            os.remove(temp_protein_pdb)
+    except Exception as e:
+        print(f"Warning: Could not remove temporary file {temp_protein_pdb}: {e}")
+    
+    # -----------------------------
+    # 7. Clean up temporary objects (keep final_model for potential reuse)
+    # -----------------------------
+    try:
+        # Delete the original and ESMFold objects, but keep final_model
+        cmd.delete(pdb_id)
+        for chain in chains_to_replace:
+            esm_obj = f"{pdb_id}_chain_{chain}_esmfold"
+            cmd.delete(esm_obj)
+    except Exception as e:
+        print(f"Warning: Could not clean up temporary objects: {e}")
+
+    print(f"✅ Final rebuilt structure saved as: {output_pdb}")
+
+
+if __name__ == "__main__":
+    # Path to the original input PDB used by the pipeline
+    original_pdb_path = "../../output/0_original_input.pdb"
+
+    # Automatically infer the PDB ID from the original PDB file,
+    # instead of hard-coding it (e.g., '3hhr').
+    pdb_id = get_pdb_id_from_pdb_file(original_pdb_path)
+    print(f"Detected PDB ID from original file: {pdb_id}")
+
+    # 1) Find missing residues for this structure
+    missing = detect_missing_residues(pdb_id)
+    chain_sequences = get_chain_sequences(pdb_id)
+
+    chains_with_missing = {
+        chain: chain_sequences[chain]
+        for chain in missing
+        if chain in chain_sequences
+    }
+
+    # 2) Write FASTA for chains with missing residues
+    write_fasta_for_missing_chains(pdb_id, chains_with_missing)
+
+    # 3) Run ESMFold for each chain and save results
+    esmfold_results = {}
+    chains_to_replace = []
+
+    for chain, seq in chains_with_missing.items():
+        print(f"Running ESMFold for chain {chain}")
+        pdb_text = run_esmfold(seq)
+        esmfold_results[chain] = pdb_text
+        chains_to_replace.append(chain)
+        # Save each chain
+        with open(f"{pdb_id}_chain_{chain}_esmfold.pdb", "w") as f:
+            f.write(pdb_text)
+
+    # 4) Rebuild PDB in PyMOL using original structure and ESMFold chains
+    rebuild_pdb_with_esmfold(
+        pdb_id,
+        chains_to_replace,
+        original_pdb_path=original_pdb_path,
+    )

amberflow/__init__.py

@@ -0,0 +1,3 @@
+"""AmberFlow: MD simulation pipeline with AMBER, ESMFold, docking, and PLUMED."""
+
+__version__ = "0.1.0"

amberflow/__main__.py

@@ -0,0 +1,11 @@
+"""Run the AmberFlow web server. Use: python -m amberflow or amberflow"""
+
+from amberflow.app import app
+
+
+def main():
+    app.run(debug=False, host="0.0.0.0", port=7860)
+
+
+if __name__ == "__main__":
+    main()

amberflow/css/plumed.css

@@ -0,0 +1,1064 @@
+/* PLUMED Section Styles */
+
+/* PLUMED Citation Note */
+.plumed-citation-note {
+    background: #e3f2fd;
+    border: 2px solid #2196f3;
+    border-left: 5px solid #2196f3;
+    border-radius: 8px;
+    padding: 1rem 1.5rem;
+    margin-bottom: 1.5rem;
+    display: flex;
+    align-items: flex-start;
+    gap: 1rem;
+    box-shadow: 0 2px 4px rgba(33, 150, 243, 0.1);
+}
+
+.plumed-citation-note i {
+    color: #2196f3;
+    font-size: 1.5rem;
+    margin-top: 0.2rem;
+    flex-shrink: 0;
+}
+
+.citation-content {
+    flex: 1;
+    color: #1565c0;
+    line-height: 1.6;
+}
+
+.citation-content p {
+    margin: 0.5rem 0;
+    font-size: 0.95rem;
+}
+
+.citation-content p:first-child {
+    margin-top: 0;
+}
+
+.citation-content p:last-child {
+    margin-bottom: 0;
+}
+
+.citation-content strong {
+    color: #0d47a1;
+    font-weight: 600;
+}
+
+.citation-content a {
+    color: #1976d2;
+    text-decoration: none;
+    font-weight: 500;
+    transition: color 0.3s ease;
+    display: inline-flex;
+    align-items: center;
+    gap: 0.25rem;
+}
+
+.citation-content a:hover {
+    color: #0d47a1;
+    text-decoration: underline;
+}
+
+.citation-content a i {
+    font-size: 0.85rem;
+    color: inherit;
+    margin: 0;
+}
+
+.plumed-container {
+    display: flex;
+    gap: 2rem;
+    margin-top: 1.5rem;
+    min-height: 600px;
+}
+
+/* Left Sidebar */
+.plumed-sidebar {
+    width: 300px;
+    background: #f8f9fa;
+    border-radius: 8px;
+    border: 1px solid #dee2e6;
+    display: flex;
+    flex-direction: column;
+    max-height: 800px;
+    overflow: hidden;
+}
+
+.sidebar-header {
+    padding: 1rem;
+    background: #2c3e50;
+    color: white;
+    border-bottom: 2px solid #3498db;
+}
+
+.sidebar-header h3 {
+    margin: 0 0 1rem 0;
+    font-size: 1.2rem;
+    font-weight: 600;
+}
+
+.sidebar-header h3 i {
+    margin-right: 0.5rem;
+    color: #3498db;
+}
+
+.search-box {
+    position: relative;
+}
+
+.search-input {
+    width: 100%;
+    padding: 0.5rem 2.5rem 0.5rem 0.75rem;
+    border: 1px solid #dee2e6;
+    border-radius: 4px;
+    font-size: 0.9rem;
+    transition: all 0.3s ease;
+}
+
+.search-input:focus {
+    outline: none;
+    border-color: #3498db;
+    box-shadow: 0 0 0 3px rgba(52, 152, 219, 0.1);
+}
+
+.search-icon {
+    position: absolute;
+    right: 0.75rem;
+    top: 50%;
+    transform: translateY(-50%);
+    color: #7f8c8d;
+    pointer-events: none;
+}
+
+.cv-list {
+    flex: 1;
+    overflow-y: auto;
+    padding: 0.5rem;
+}
+
+.cv-item {
+    padding: 0.75rem 1rem;
+    margin-bottom: 0.5rem;
+    background: white;
+    border: 1px solid #dee2e6;
+    border-radius: 6px;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+}
+
+.cv-item:hover {
+    background: #e3f2fd;
+    border-color: #3498db;
+    transform: translateX(5px);
+}
+
+.cv-item.active {
+    background: #3498db;
+    color: white;
+    border-color: #2980b9;
+    box-shadow: 0 2px 8px rgba(52, 152, 219, 0.3);
+}
+
+.cv-item-name {
+    font-weight: 600;
+    font-size: 0.95rem;
+}
+
+.cv-item-category {
+    font-size: 0.75rem;
+    opacity: 0.7;
+    margin-top: 0.25rem;
+}
+
+.cv-item.active .cv-item-category {
+    opacity: 0.9;
+}
+
+.cv-item-icon {
+    color: #3498db;
+    margin-left: 0.5rem;
+}
+
+.cv-item.active .cv-item-icon {
+    color: white;
+}
+
+/* Right Content Panel */
+.plumed-content {
+    flex: 1;
+    background: white;
+    border-radius: 8px;
+    border: 1px solid #dee2e6;
+    padding: 1.5rem;
+    overflow-y: auto;
+    max-height: 800px;
+}
+
+.content-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1.5rem;
+    padding-bottom: 1rem;
+    border-bottom: 2px solid #e1e8ed;
+}
+
+.content-header h3 {
+    margin: 0;
+    color: #2c3e50;
+    font-size: 1.5rem;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.plumed-doc-link {
+    color: #3498db;
+    text-decoration: none;
+    font-size: 0.85em;
+    margin-left: 0.5rem;
+    transition: color 0.3s ease;
+    display: inline-flex;
+    align-items: center;
+    gap: 0.25rem;
+}
+
+.plumed-doc-link:hover {
+    color: #2980b9;
+    text-decoration: underline;
+}
+
+.plumed-doc-link i {
+    font-size: 0.75em;
+}
+
+.welcome-message {
+    text-align: center;
+    padding: 3rem 1rem;
+    color: #7f8c8d;
+}
+
+.welcome-message i {
+    color: #bdc3c7;
+    margin-bottom: 1rem;
+}
+
+.welcome-message h3 {
+    color: #2c3e50;
+    margin: 1rem 0;
+}
+
+/* Documentation Sections */
+.cv-documentation {
+    margin-bottom: 2rem;
+}
+
+.doc-section {
+    margin-bottom: 2rem;
+    padding: 1.5rem;
+    background: #f8f9fa;
+    border-radius: 8px;
+    border-left: 4px solid #3498db;
+}
+
+.doc-section h4 {
+    color: #2c3e50;
+    margin-bottom: 1rem;
+    font-size: 1.2rem;
+    display: flex;
+    align-items: center;
+}
+
+.doc-section h4 {
+    display: flex;
+    align-items: center;
+    margin-bottom: 1rem;
+}
+
+.doc-section h4 i {
+    margin-right: 0.5rem;
+    color: #3498db;
+}
+
+/* Options heading with legend on the right - only apply space-between to headings with color-legend */
+.doc-section h4 .color-legend {
+    margin-left: auto;
+}
+
+/* For browsers that support :has() */
+@supports selector(:has(*)) {
+    .doc-section h4:has(.color-legend) {
+        justify-content: space-between;
+        flex-wrap: wrap;
+        gap: 1rem;
+    }
+}
+
+/* Fallback for browsers without :has() support - use a class */
+.doc-section h4.options-heading-with-legend {
+    justify-content: space-between;
+    flex-wrap: wrap;
+    gap: 1rem;
+}
+
+.color-legend {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+    font-size: 0.85rem;
+    font-weight: normal;
+    color: #7f8c8d;
+    margin-left: auto;
+}
+
+.legend-item {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.legend-item code {
+    font-size: 0.8rem;
+    padding: 0.25rem 0.5rem;
+}
+
+.doc-content {
+    color: #555;
+    line-height: 1.8;
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+}
+
+.description-paragraph {
+    margin-bottom: 1rem;
+    line-height: 1.8;
+}
+
+.description-list {
+    list-style: none;
+    padding-left: 0;
+    margin: 1rem 0;
+}
+
+.description-list li {
+    padding: 0.5rem 0 0.5rem 1.5rem;
+    position: relative;
+    line-height: 1.8;
+    margin-bottom: 0.5rem;
+}
+
+.description-list li::before {
+    content: '•';
+    position: absolute;
+    left: 0;
+    color: #3498db;
+    font-size: 1.2em;
+    font-weight: bold;
+    line-height: 1.4;
+}
+
+.description-list li:last-child {
+    margin-bottom: 0;
+}
+
+/* Ensure Unicode mathematical symbols render correctly */
+.doc-content,
+.math-formula {
+    font-variant-numeric: normal;
+    text-rendering: optimizeLegibility;
+    -webkit-font-feature-settings: "kern" 1;
+    font-feature-settings: "kern" 1;
+}
+
+.syntax-box,
+.example-box {
+    background: #2c3e50;
+    color: #ecf0f1;
+    padding: 1rem;
+    border-radius: 6px;
+    overflow-x: auto;
+    font-family: 'Courier New', monospace;
+    font-size: 0.9rem;
+    line-height: 1.6;
+    margin: 0;
+    white-space: pre-wrap;
+    word-wrap: break-word;
+}
+
+.example-box {
+    background: #34495e;
+    border-left: 4px solid #3498db;
+}
+
+/* Editor Section */
+.cv-editor-section {
+    margin-top: 2rem;
+    border-top: 2px solid #e1e8ed;
+    padding-top: 1.5rem;
+}
+
+.editor-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1rem;
+}
+
+.editor-header h4 {
+    color: #2c3e50;
+    margin: 0;
+    font-size: 1.1rem;
+}
+
+.editor-header h4 i {
+    margin-right: 0.5rem;
+    color: #3498db;
+}
+
+.editor-actions {
+    display: flex;
+    gap: 0.5rem;
+}
+
+.cv-editor {
+    width: 100%;
+    min-height: 300px;
+    padding: 1rem;
+    border: 2px solid #dee2e6;
+    border-radius: 6px;
+    font-family: 'Courier New', monospace;
+    font-size: 0.9rem;
+    line-height: 1.6;
+    resize: vertical;
+    transition: border-color 0.3s ease;
+}
+
+.cv-editor:focus {
+    outline: none;
+    border-color: #3498db;
+    box-shadow: 0 0 0 3px rgba(52, 152, 219, 0.1);
+}
+
+.editor-footer {
+    display: flex;
+    justify-content: space-between;
+    margin-top: 0.5rem;
+    font-size: 0.85rem;
+    color: #7f8c8d;
+}
+
+/* Saved Configurations */
+.saved-configs {
+    margin-top: 2rem;
+    padding-top: 1.5rem;
+    border-top: 2px solid #e1e8ed;
+}
+
+.saved-configs h4 {
+    color: #2c3e50;
+    margin-bottom: 1rem;
+    font-size: 1.1rem;
+}
+
+.saved-configs h4 i {
+    margin-right: 0.5rem;
+    color: #3498db;
+}
+
+.config-item {
+    background: #f8f9fa;
+    border: 1px solid #dee2e6;
+    border-radius: 6px;
+    padding: 1rem;
+    margin-bottom: 0.75rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    transition: all 0.3s ease;
+}
+
+.config-item:hover {
+    background: #e3f2fd;
+    border-color: #3498db;
+}
+
+.config-item-name {
+    font-weight: 600;
+    color: #2c3e50;
+}
+
+.config-item-actions {
+    display: flex;
+    gap: 0.5rem;
+}
+
+.config-item-actions button {
+    padding: 0.25rem 0.75rem;
+    font-size: 0.85rem;
+}
+
+/* Section Description */
+.section-description {
+    color: #7f8c8d;
+    margin-bottom: 1.5rem;
+    font-style: italic;
+}
+
+/* Glossary and Options Lists */
+.glossary-content,
+.options-list,
+.components-list {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+}
+
+.glossary-item {
+    background: white;
+    padding: 1rem;
+    border-radius: 6px;
+    border-left: 3px solid #9b59b6;
+    margin-bottom: 0.5rem;
+}
+
+.glossary-item strong {
+    color: #2c3e50;
+    font-size: 1rem;
+    display: inline-block;
+    margin-right: 0.5rem;
+}
+
+.glossary-item p {
+    margin: 0.5rem 0 0 0;
+    color: #555;
+    line-height: 1.6;
+}
+
+.glossary-content > p {
+    font-weight: 600;
+    color: #2c3e50;
+    margin-bottom: 1rem;
+}
+
+/* Options Keywords - Horizontal Layout */
+.options-keywords {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.75rem;
+    align-items: center;
+    padding: 1rem;
+    background: #f8f9fa;
+    border-radius: 6px;
+    border: 1px solid #dee2e6;
+}
+
+.options-keywords code {
+    padding: 0.5rem 0.75rem;
+    border-radius: 4px;
+    font-family: 'Courier New', monospace;
+    font-size: 0.9rem;
+    font-weight: 600;
+    white-space: nowrap;
+    display: inline-block;
+    transition: all 0.2s ease;
+}
+
+.keyword-required {
+    background: #fee;
+    color: #c33;
+    border: 1px solid #fcc;
+}
+
+.keyword-required:hover {
+    background: #fdd;
+    border-color: #c33;
+    transform: translateY(-1px);
+    box-shadow: 0 2px 4px rgba(204, 51, 51, 0.2);
+}
+
+.keyword-optional {
+    background: #f5f5f5;
+    color: #666;
+    border: 1px solid #ddd;
+}
+
+.keyword-optional:hover {
+    background: #eee;
+    border-color: #999;
+    transform: translateY(-1px);
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+/* Components Lists */
+.components-list {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+}
+
+.component-item {
+    background: white;
+    padding: 1rem;
+    border-radius: 6px;
+    border-left: 3px solid #3498db;
+    margin-bottom: 0.5rem;
+}
+
+.component-item strong {
+    color: #2c3e50;
+    font-size: 1rem;
+    display: inline-block;
+    margin-right: 0.5rem;
+}
+
+.component-item p {
+    margin: 0.5rem 0 0 0;
+    color: #555;
+    line-height: 1.6;
+}
+
+/* Notes List */
+.notes-list {
+    list-style: none;
+    padding: 0;
+}
+
+.notes-list li {
+    padding: 0.75rem;
+    margin-bottom: 0.5rem;
+    background: #fff3cd;
+    border-left: 3px solid #ffc107;
+    border-radius: 4px;
+    color: #856404;
+}
+
+.notes-list li::before {
+    content: "ℹ️";
+    margin-right: 0.5rem;
+}
+
+/* Math Formulas */
+.math-formula {
+    background: #f8f9fa;
+    padding: 0.75rem;
+    border-radius: 4px;
+    margin: 0.75rem 0;
+    font-family: 'Times New Roman', 'DejaVu Serif', serif;
+    font-size: 1rem;
+    border-left: 3px solid #3498db;
+    white-space: pre-wrap;
+    line-height: 1.8;
+    color: #2c3e50;
+    font-style: italic;
+}
+
+/* Mathematical formatting */
+.math-fraction {
+    display: inline-flex;
+    flex-direction: column;
+    vertical-align: middle;
+    text-align: center;
+    margin: 0 0.3em;
+    line-height: 1;
+    font-size: 1.1em;
+}
+
+.math-numerator {
+    border-bottom: 1.5px solid currentColor;
+    padding: 0 0.3em 0.1em 0.3em;
+    line-height: 1.1;
+}
+
+.math-denominator {
+    padding: 0.1em 0.3em 0 0.3em;
+    line-height: 1.1;
+}
+
+.math-sqrt {
+    display: inline-block;
+    position: relative;
+    vertical-align: middle;
+    margin: 0 0.2em;
+    font-size: 1.1em;
+}
+
+.math-sqrt-symbol {
+    font-size: 1.3em;
+    vertical-align: middle;
+    margin-right: 0.1em;
+    line-height: 1;
+}
+
+.math-radicand {
+    display: inline-block;
+    padding: 0.1em 0.3em;
+    margin-left: 0.1em;
+    border-top: 1.5px solid currentColor;
+    vertical-align: middle;
+}
+
+.math-formula sup,
+.math-formula sub,
+.description-paragraph sup,
+.description-paragraph sub,
+.description-list li sup,
+.description-list li sub {
+    font-size: 0.75em;
+    line-height: 0;
+    position: relative;
+    vertical-align: baseline;
+    font-weight: normal;
+}
+
+.math-formula sup,
+.description-paragraph sup,
+.description-list li sup {
+    top: -0.5em;
+}
+
+.math-formula sub,
+.description-paragraph sub,
+.description-list li sub {
+    bottom: -0.25em;
+}
+
+/* Ensure proper rendering of subscripts and superscripts in all contexts */
+.doc-content sup,
+.doc-content sub {
+    font-size: 0.75em;
+    line-height: 0;
+    position: relative;
+    vertical-align: baseline;
+}
+
+.doc-content sup {
+    top: -0.5em;
+}
+
+.doc-content sub {
+    bottom: -0.25em;
+}
+
+.doc-content sub {
+    font-size: 0.8em;
+    vertical-align: sub;
+}
+
+.doc-content code {
+    background: #f1f3f5;
+    padding: 0.2rem 0.4rem;
+    border-radius: 3px;
+    font-family: 'Courier New', monospace;
+    font-size: 0.9em;
+}
+
+/* Related CVs */
+.related-cvs {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+}
+
+.related-cv-badge {
+    display: inline-block;
+    padding: 0.5rem 1rem;
+    background: #e3f2fd;
+    color: #1976d2;
+    border-radius: 20px;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    font-weight: 500;
+    border: 1px solid #90caf9;
+}
+
+.related-cv-badge:hover {
+    background: #1976d2;
+    color: white;
+    transform: translateY(-2px);
+    box-shadow: 0 2px 8px rgba(25, 118, 210, 0.3);
+}
+
+/* Responsive Design */
+@media (max-width: 1024px) {
+    .plumed-container {
+        flex-direction: column;
+    }
+    
+    .plumed-sidebar {
+        width: 100%;
+        max-height: 300px;
+    }
+}
+
+/* Scrollbar Styling */
+.cv-list::-webkit-scrollbar,
+.plumed-content::-webkit-scrollbar {
+    width: 8px;
+}
+
+.cv-list::-webkit-scrollbar-track,
+.plumed-content::-webkit-scrollbar-track {
+    background: #f1f1f1;
+    border-radius: 4px;
+}
+
+.cv-list::-webkit-scrollbar-thumb,
+.plumed-content::-webkit-scrollbar-thumb {
+    background: #bdc3c7;
+    border-radius: 4px;
+}
+
+.cv-list::-webkit-scrollbar-thumb:hover,
+.plumed-content::-webkit-scrollbar-thumb:hover {
+    background: #95a5a6;
+}
+
+/* PLUMED Section Cards */
+.plumed-section-card {
+    margin-bottom: 1.5rem;
+}
+
+.plumed-section-card:last-child {
+    margin-bottom: 0;
+}
+
+/* PLUMED Section Headers - Smaller font size */
+.plumed-section-card h2 {
+    font-size: 1.4rem !important;
+}
+
+/* Collapsed state - hide content but keep header visible */
+.plumed-section-card.collapsed .section-description,
+.plumed-section-card.collapsed .plumed-container,
+.plumed-section-card.collapsed .plumed-generate-section,
+.plumed-section-card.collapsed .generate-simulation-files-section {
+    max-height: 0;
+    opacity: 0;
+    margin-top: 0;
+    margin-bottom: 0;
+    padding-top: 0;
+    padding-bottom: 0;
+    overflow: hidden;
+    transition: max-height 0.4s ease, opacity 0.3s ease, margin 0.3s ease, padding 0.3s ease;
+}
+
+/* Keep header visible even when collapsed */
+.plumed-section-card.collapsed .plumed-toggle-header {
+    margin-bottom: 0;
+}
+
+/* Collapsible Header */
+.plumed-toggle-header {
+    cursor: pointer;
+    user-select: none;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    transition: color 0.3s ease;
+    padding: 0.5rem;
+    margin: -0.5rem;
+    border-radius: 4px;
+    text-align: left !important;
+}
+
+.plumed-toggle-header > i:first-of-type {
+    margin-right: 0.5rem;
+}
+
+/* Ensure left alignment for custom PLUMED header */
+#custom-plumed-card h2,
+#custom-plumed-card .plumed-toggle-header {
+    text-align: left !important;
+    justify-content: flex-start !important;
+}
+
+#custom-plumed-card .plumed-toggle-header {
+    display: flex !important;
+    align-items: center;
+}
+
+#custom-plumed-card .plumed-toggle-header > *:first-child {
+    margin-right: 0.5rem;
+}
+
+#custom-plumed-card .plumed-toggle-header .toggle-icon {
+    margin-left: auto;
+    margin-right: 0;
+}
+
+/* Generate Simulation Files Section - Left Aligned */
+#generate-simulation-files-card h2,
+#generate-simulation-files-card .plumed-toggle-header {
+    text-align: left !important;
+    justify-content: flex-start !important;
+}
+
+#generate-simulation-files-card .plumed-toggle-header {
+    display: flex !important;
+    align-items: center;
+}
+
+#generate-simulation-files-card .plumed-toggle-header > *:first-child {
+    margin-right: 0.5rem;
+}
+
+#generate-simulation-files-card .plumed-toggle-header .toggle-icon {
+    margin-left: auto;
+    margin-right: 0;
+}
+
+.plumed-toggle-header:hover {
+    background: rgba(52, 152, 219, 0.1);
+    color: #3498db;
+}
+
+.toggle-icon {
+    transition: transform 0.3s ease;
+    font-size: 0.9em;
+    color: #7f8c8d;
+}
+
+.plumed-toggle-header.collapsed .toggle-icon {
+    transform: rotate(-90deg);
+}
+
+.plumed-container,
+.plumed-generate-section {
+    transition: max-height 0.4s ease, opacity 0.3s ease, margin 0.3s ease;
+    overflow: hidden;
+}
+
+.section-description {
+    transition: max-height 0.4s ease, opacity 0.3s ease, margin 0.3s ease, padding 0.3s ease;
+    overflow: hidden;
+}
+
+/* Generate Files Section */
+.plumed-generate-section {
+    margin-top: 1.5rem;
+    padding-top: 1.5rem;
+}
+
+.generate-content {
+    display: flex;
+    flex-direction: column;
+    gap: 1.5rem;
+}
+
+.generate-options {
+    display: flex;
+    gap: 1rem;
+    flex-wrap: wrap;
+}
+
+.generate-options .btn {
+    padding: 0.75rem 1.5rem;
+    font-size: 1rem;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.generated-file-preview {
+    background: #f8f9fa;
+    border: 1px solid #dee2e6;
+    border-radius: 8px;
+    padding: 1.5rem;
+    margin-top: 1rem;
+}
+
+.generated-file-preview h4 {
+    margin: 0 0 1rem 0;
+    color: #2c3e50;
+    font-size: 1.1rem;
+}
+
+.file-preview {
+    background: #2c3e50;
+    color: #ecf0f1;
+    padding: 1rem;
+    border-radius: 4px;
+    overflow-x: auto;
+    font-family: 'Courier New', monospace;
+    font-size: 0.9rem;
+    line-height: 1.6;
+    margin: 0;
+    max-height: 400px;
+    overflow-y: auto;
+}
+
+/* Custom PLUMED File Section */
+.custom-plumed-section {
+    margin-top: 1.5rem;
+    transition: max-height 0.4s ease, opacity 0.3s ease, margin 0.3s ease, padding 0.3s ease;
+    overflow: hidden;
+}
+
+/* Collapsed state for custom PLUMED section */
+#custom-plumed-card.collapsed .section-description,
+#custom-plumed-card.collapsed .custom-plumed-section {
+    max-height: 0;
+    opacity: 0;
+    margin-top: 0;
+    margin-bottom: 0;
+    padding-top: 0;
+    padding-bottom: 0;
+    overflow: hidden;
+}
+
+/* Keep header visible even when collapsed */
+#custom-plumed-card.collapsed .plumed-toggle-header {
+    margin-bottom: 0;
+}
+
+.custom-editor-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1rem;
+    padding-bottom: 0.75rem;
+    border-bottom: 2px solid #dee2e6;
+}
+
+.custom-editor-header h4 {
+    margin: 0;
+    color: #2c3e50;
+    font-size: 1.1rem;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.custom-editor-header h4 i {
+    color: #3498db;
+}
+
+.custom-plumed-editor {
+    width: 100%;
+    min-height: 400px;
+    padding: 1rem;
+    border: 2px solid #dee2e6;
+    border-radius: 8px;
+    font-family: 'Courier New', monospace;
+    font-size: 0.95rem;
+    line-height: 1.6;
+    resize: vertical;
+    background: #ffffff;
+    color: #2c3e50;
+    transition: border-color 0.3s ease;
+}
+
+.custom-plumed-editor:focus {
+    outline: none;
+    border-color: #3498db;
+    box-shadow: 0 0 0 3px rgba(52, 152, 219, 0.1);
+}
+
+.custom-plumed-editor::placeholder {
+    color: #95a5a6;
+    font-style: italic;
+}
+

{css → amberflow/css}/styles.css

@@ -231,6 +231,43 @@ body {
     color: #3498db;
 }
 
+/* File Generation Note */
+.file-generation-note {
+    background: #fff3cd;
+    border: 2px solid #ffc107;
+    border-left: 5px solid #ffc107;
+    border-radius: 8px;
+    padding: 1rem 1.5rem;
+    margin-bottom: 1.5rem;
+    display: flex;
+    align-items: flex-start;
+    gap: 1rem;
+    box-shadow: 0 2px 4px rgba(255, 193, 7, 0.1);
+}
+
+.file-generation-note i {
+    color: #856404;
+    font-size: 1.5rem;
+    margin-top: 0.2rem;
+    flex-shrink: 0;
+}
+
+.file-generation-note .note-content {
+    flex: 1;
+    color: #856404;
+    line-height: 1.6;
+}
+
+.file-generation-note .note-content p {
+    margin: 0;
+    font-size: 0.95rem;
+}
+
+.file-generation-note .note-content strong {
+    color: #664d03;
+    font-weight: 600;
+}
+
 /* Protein Loading Styles */
 .input-methods {
     display: grid;
@@ -398,6 +435,32 @@ body {
     margin-top: 1rem;
 }
 
+/* Structure comparison container - force side by side and centered */
+.structure-comparison-container {
+    display: flex !important;
+    flex-direction: row !important;
+    width: 100% !important;
+    max-width: 1400px !important;
+    gap: 20px !important;
+    margin: 0 auto !important;
+    justify-content: center !important;
+}
+
+.structure-comparison-container .comparison-viewer {
+    flex: 0 1 48% !important;
+    min-width: 450px !important;
+    max-width: 48% !important;
+}
+
+/* Override preview-content for comparison view */
+#completed-structure-preview .preview-content {
+    display: flex !important;
+    justify-content: center !important;
+    width: 100% !important;
+    padding: 0 !important;
+    grid-template-columns: none !important;
+}
+
 .protein-info p {
     margin: 0.5rem 0;
     font-size: 1rem;
@@ -952,6 +1015,12 @@ input:checked + .slider:before {
     color: #3498db;
 }
 
+.prep-section-fullwidth {
+    width: 100%;
+    margin-top: 1rem;
+    margin-bottom: 2rem;
+}
+
 .prep-options {
     display: flex;
     flex-direction: column;
@@ -1022,6 +1091,13 @@ input:checked + .slider:before {
     padding: 1.5rem;
     border: 1px solid #dee2e6;
     margin-top: 2rem;
+    width: 100%;
+    box-sizing: border-box;
+}
+
+#sequence-viewer-section {
+    width: 100%;
+    box-sizing: border-box;
 }
 
 .prepared-structure-preview h3 {
@@ -1111,3 +1187,835 @@ input:checked + .slider:before {
 .p-1 { padding: 0.5rem; }
 .p-2 { padding: 1rem; }
 .p-3 { padding: 1.5rem; }
+
+/* Missing Residues Horizontal Display */
+.missing-residues-horizontal {
+    display: inline;
+    color: #155724;
+    font-weight: bold;
+    font-size: 0.95rem;
+    word-wrap: break-word;
+    white-space: normal;
+    line-height: 1.6;
+    margin: 0;
+    padding: 0;
+}
+
+.chain-missing-info {
+    margin-bottom: 1.5rem;
+}
+
+.chain-missing-info h4 {
+    color: #155724;
+    margin-bottom: 0.5rem;
+}
+
+/* Sequence Viewer Styles */
+.sequence-viewer-container {
+    background: #ffffff;
+    border: 1px solid #dee2e6;
+    border-radius: 8px;
+    padding: 1.5rem;
+    max-height: 600px;
+    overflow-y: auto;
+    font-family: 'Courier New', monospace;
+    width: 100%;
+    box-sizing: border-box;
+}
+
+.sequence-chain-container {
+    margin-bottom: 2rem;
+    border-bottom: 2px solid #e9ecef;
+    padding-bottom: 1.5rem;
+}
+
+.sequence-chain-container:last-child {
+    border-bottom: none;
+    margin-bottom: 0;
+}
+
+.sequence-chain-header {
+    margin-bottom: 1rem;
+}
+
+.sequence-chain-header h4 {
+    margin: 0;
+    font-size: 1.1rem;
+    font-weight: 600;
+}
+
+.sequence-display {
+    background: #f8f9fa;
+    border: 1px solid #dee2e6;
+    border-radius: 4px;
+    padding: 1rem;
+    font-size: 14px;
+    line-height: 1.8;
+    width: 100%;
+    box-sizing: border-box;
+}
+
+.sequence-line {
+    display: flex;
+    margin-bottom: 2px;
+    white-space: nowrap;
+}
+
+.sequence-line-number {
+    color: #6c757d;
+    margin-right: 1rem;
+    min-width: 60px;
+    text-align: right;
+    font-size: 12px;
+    user-select: none;
+}
+
+.sequence-characters {
+    letter-spacing: 2px;
+    word-spacing: 0;
+    flex: 1;
+    overflow-x: auto;
+    min-width: 0;
+}
+
+.sequence-char {
+    display: inline-block;
+    padding: 2px 1px;
+    transition: background-color 0.2s;
+}
+
+.sequence-char:hover {
+    background-color: rgba(0, 0, 0, 0.1);
+    border-radius: 2px;
+}
+
+/* Trim Residues Section */
+.trim-info-box {
+    background: #e7f3ff;
+    border: 1px solid #b3d9ff;
+    border-radius: 6px;
+    padding: 1rem;
+    margin-top: 1rem;
+    margin-bottom: 1rem;
+    color: #004085;
+    font-size: 0.9rem;
+    line-height: 1.6;
+}
+
+.trim-info-box i {
+    color: #0066cc;
+    margin-right: 0.5rem;
+}
+
+.trim-info-box strong {
+    color: #003366;
+}
+
+.trim-residues-container {
+    margin-top: 1rem;
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+    gap: 1rem;
+}
+
+.trim-chain-controls {
+    background: #f8f9fa;
+    border: 1px solid #dee2e6;
+    border-radius: 6px;
+    padding: 1rem;
+}
+
+.trim-chain-controls h5 {
+    color: #2c3e50;
+    margin-bottom: 0.75rem;
+    font-size: 1rem;
+}
+
+.trim-inputs {
+    display: flex;
+    gap: 1.5rem;
+    align-items: center;
+    flex-wrap: wrap;
+}
+
+.trim-input-group {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.trim-input-group label {
+    font-weight: 600;
+    color: #495057;
+    font-size: 0.9rem;
+    min-width: 100px;
+}
+
+.trim-limit {
+    font-weight: normal;
+    color: #6c757d;
+    font-size: 0.85rem;
+    font-style: italic;
+}
+
+.trim-input-group input[type="number"] {
+    width: 80px;
+    padding: 0.5rem;
+    border: 1px solid #ced4da;
+    border-radius: 4px;
+    font-size: 0.9rem;
+}
+
+.trim-input-group input[type="number"]:focus {
+    outline: none;
+    border-color: #3498db;
+    box-shadow: 0 0 0 3px rgba(52, 152, 219, 0.1);
+}
+
+.trim-info {
+    font-size: 0.85rem;
+    color: #6c757d;
+    margin-top: 0.5rem;
+    font-style: italic;
+}
+
+/* Log Modal Styles */
+.log-modal {
+    display: none;
+    position: fixed;
+    z-index: 10000;
+    left: 0;
+    top: 0;
+    width: 100%;
+    height: 100%;
+    background-color: rgba(0, 0, 0, 0.5);
+    animation: fadeIn 0.3s;
+}
+
+@keyframes fadeIn {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+
+.log-modal-content {
+    background-color: #fefefe;
+    margin: 2% auto;
+    padding: 0;
+    border: 1px solid #888;
+    border-radius: 8px;
+    width: 90%;
+    max-width: 900px;
+    max-height: 90vh;
+    display: flex;
+    flex-direction: column;
+    box-shadow: 0 4px 20px rgba(0, 0, 0, 0.3);
+    animation: slideDown 0.3s;
+}
+
+@keyframes slideDown {
+    from {
+        transform: translateY(-50px);
+        opacity: 0;
+    }
+    to {
+        transform: translateY(0);
+        opacity: 1;
+    }
+}
+
+.log-modal-header {
+    background: linear-gradient(135deg, #2c3e50 0%, #3498db 100%);
+    color: white;
+    padding: 1rem 1.5rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    border-radius: 8px 8px 0 0;
+}
+
+.log-modal-header h3 {
+    margin: 0;
+    font-size: 1.3rem;
+    font-weight: 500;
+}
+
+.log-modal-close {
+    color: white;
+    font-size: 2rem;
+    font-weight: bold;
+    background: none;
+    border: none;
+    cursor: pointer;
+    padding: 0;
+    width: 30px;
+    height: 30px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 50%;
+    transition: background-color 0.2s;
+}
+
+.log-modal-close:hover {
+    background-color: rgba(255, 255, 255, 0.2);
+}
+
+.log-container {
+    flex: 1;
+    overflow-y: auto;
+    padding: 1rem;
+    background-color: #1e1e1e;
+    color: #d4d4d4;
+    font-family: 'Courier New', monospace;
+    font-size: 0.9rem;
+    line-height: 1.6;
+    max-height: calc(90vh - 80px);
+}
+
+.log-content {
+    min-height: 100%;
+}
+
+.log-line {
+    padding: 0.3rem 0;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.05);
+    word-wrap: break-word;
+}
+
+.log-line:last-child {
+    border-bottom: none;
+}
+
+.log-time {
+    color: #858585;
+    margin-right: 0.5rem;
+}
+
+.log-icon {
+    margin-right: 0.5rem;
+}
+
+.log-message {
+    color: #d4d4d4;
+}
+
+.log-info .log-message {
+    color: #d4d4d4;
+}
+
+.log-success .log-message {
+    color: #4ec9b0;
+}
+
+.log-warning .log-message {
+    color: #dcdcaa;
+}
+
+.log-error .log-message {
+    color: #f48771;
+}
+
+.log-result {
+    margin-top: 1.5rem;
+    padding: 1rem;
+    background-color: #252526;
+    border-left: 4px solid #4ec9b0;
+    border-radius: 4px;
+}
+
+.log-result h4 {
+    color: #4ec9b0;
+    margin-bottom: 0.5rem;
+}
+
+.log-result p {
+    color: #d4d4d4;
+    margin: 0.5rem 0;
+}
+
+.log-result ul {
+    margin: 0.5rem 0;
+    padding-left: 1.5rem;
+    color: #d4d4d4;
+}
+
+.log-result li {
+    margin: 0.5rem 0;
+}
+
+/* File Editor Modal Styles */
+#file-content-modal {
+    animation: fadeIn 0.3s;
+}
+
+#file-content-modal > div {
+    animation: slideDown 0.3s;
+}
+
+#modal-content-edit {
+    line-height: 1.6;
+    tab-size: 4;
+    -moz-tab-size: 4;
+}
+
+#modal-content-edit:focus {
+    outline: none;
+    border-color: #0056b3;
+    box-shadow: 0 0 0 3px rgba(0, 123, 255, 0.25);
+}
+
+#save-status {
+    font-weight: 500;
+    animation: slideUp 0.3s;
+}
+
+@keyframes slideUp {
+    from {
+        opacity: 0;
+        transform: translateY(10px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+#edit-file-btn:hover {
+    background: #0056b3 !important;
+}
+
+#save-file-btn:hover {
+    background: #218838 !important;
+}
+
+#cancel-edit-btn:hover {
+    background: #5a6268 !important;
+}
+
+/* Frozen/Disabled Checkboxes - Gray only the checkbox, keep text bold and normal */
+.checkbox-container input[type="checkbox"]:disabled {
+    opacity: 0.5 !important;
+    cursor: not-allowed !important;
+    pointer-events: none !important;
+    -webkit-appearance: none !important;
+    appearance: none !important;
+}
+
+.checkbox-container input[type="checkbox"]:disabled + .checkmark {
+    opacity: 0.5 !important;
+}
+
+/* Keep text labels bold and normal color when checkbox is disabled */
+.checkbox-container:has(input[type="checkbox"]:disabled) {
+    cursor: not-allowed !important;
+    pointer-events: none !important;
+    opacity: 1 !important;
+    color: #2c3e50 !important;
+    font-weight: 600 !important;
+}
+
+.checkbox-container:has(input[type="checkbox"]:disabled):hover {
+    color: #2c3e50 !important;
+}
+
+/* Prevent interaction on disabled checkbox inputs */
+.checkbox-container input[type="checkbox"]:disabled {
+    cursor: not-allowed !important;
+    pointer-events: none !important;
+    opacity: 0.5 !important;
+}
+
+/* Gray out the checkmark for disabled checkboxes */
+.checkbox-container input[type="checkbox"]:disabled:checked {
+    background-color: #6c757d !important;
+    border-color: #6c757d !important;
+}
+
+.checkbox-container input[type="checkbox"]:disabled:checked::after {
+    color: #ffffff !important;
+}
+
+/* Frozen/Disabled Toggle Switches - Gray only the toggle, keep it hidden */
+.switch input[type="checkbox"]:disabled {
+    opacity: 0 !important; /* Keep the input completely hidden */
+    cursor: not-allowed !important;
+    pointer-events: none !important;
+    width: 0 !important;
+    height: 0 !important;
+}
+
+.switch input[type="checkbox"]:disabled + .slider {
+    opacity: 0.5 !important;
+    cursor: not-allowed !important;
+    pointer-events: none !important;
+    background-color: #95a5a6 !important; /* Gray color for disabled toggles */
+}
+
+.switch input[type="checkbox"]:disabled:checked + .slider {
+    background-color: #95a5a6 !important; /* Gray color even when checked */
+}
+
+.switch input[type="checkbox"]:disabled:not(:checked) + .slider {
+    background-color: #bdc3c7 !important; /* Lighter gray when unchecked */
+}
+
+.switch:has(input[type="checkbox"]:disabled) {
+    cursor: not-allowed !important;
+    pointer-events: none !important;
+    opacity: 1 !important; /* Keep switch container visible */
+}
+
+.switch:has(input[type="checkbox"]:disabled) .slider {
+    cursor: not-allowed !important;
+    pointer-events: none !important;
+}
+
+/* Ensure disabled switch input stays completely hidden */
+.switch input[type="checkbox"]:disabled {
+    position: absolute !important;
+    opacity: 0 !important;
+    width: 0 !important;
+    height: 0 !important;
+    margin: 0 !important;
+    padding: 0 !important;
+}
+
+/* Docking Section Collapsible Styles */
+#docking-section.collapsed .section-description,
+#docking-section.collapsed .custom-plumed-section {
+    max-height: 0;
+    opacity: 0;
+    margin-top: 0;
+    margin-bottom: 0;
+    padding-top: 0;
+    padding-bottom: 0;
+    overflow: hidden;
+    transition: max-height 0.4s ease, opacity 0.3s ease, margin 0.3s ease, padding 0.3s ease;
+}
+
+#docking-section.collapsed .plumed-toggle-header {
+    margin-bottom: 0;
+}
+
+.docking-box-row {
+    display: flex;
+    gap: 10px;
+    margin-bottom: 10px;
+}
+
+.docking-box-row .form-group {
+    flex: 1;
+}
+
+.docking-setup-entry {
+    margin-bottom: 15px;
+    padding: 10px;
+    background: white;
+    border-radius: 5px;
+    border: 1px solid #dee2e6;
+}
+
+.docking-setup-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 10px;
+}
+
+.docking-setup-chains {
+    font-size: 0.9em;
+    color: #6c757d;
+}
+
+/* Docking Ligand Selection Row Styles */
+.docking-ligand-row {
+    transition: all 0.2s ease;
+}
+
+.docking-ligand-row:hover {
+    background: #e9ecef !important;
+    border-color: #6f42c1 !important;
+}
+
+.docking-ligand-row .checkbox-container {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+/* Docking Box Controls Compact Layout */
+#docking-setup-list {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 15px;
+}
+
+.docking-setup-entry {
+    transition: all 0.2s ease;
+}
+
+.docking-setup-entry:hover {
+    border-color: #6f42c1 !important;
+    box-shadow: 0 2px 8px rgba(111, 66, 193, 0.15);
+}
+
+.docking-setup-entry input[type="number"] {
+    transition: border-color 0.2s ease;
+}
+
+.docking-setup-entry input[type="number"]:focus {
+    border-color: #6f42c1;
+    outline: none;
+    box-shadow: 0 0 0 2px rgba(111, 66, 193, 0.1);
+}
+
+/* Small checkmarks for chain selection */
+.docking-ligand-row .checkmark {
+    width: 16px !important;
+    height: 16px !important;
+}
+
+.docking-ligand-row .checkmark:after {
+    left: 5px !important;
+    top: 2px !important;
+    width: 4px !important;
+    height: 8px !important;
+}
+
+
+/* Docking Setup Collapsible Section */
+.docking-setup-collapsible {
+    transition: all 0.3s ease;
+}
+
+.docking-setup-header {
+    user-select: none;
+    transition: background 0.2s ease;
+}
+
+.docking-setup-header:hover {
+    background: linear-gradient(135deg, #5a31a8 0%, #7d4bc7 100%) !important;
+}
+
+.docking-setup-content {
+    transition: all 0.3s ease;
+}
+
+#docking-setup-toggle-icon {
+    transition: transform 0.3s ease;
+}
+
+/* Docking Poses Viewer Styles */
+.docking-ligand-tabs {
+    display: flex;
+    gap: 8px;
+    margin-bottom: 15px;
+    flex-wrap: wrap;
+}
+
+.docking-ligand-tab {
+    padding: 8px 16px;
+    border: 2px solid #dee2e6;
+    border-radius: 6px;
+    background: #f8f9fa;
+    cursor: pointer;
+    font-weight: 500;
+    transition: all 0.2s ease;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.docking-ligand-tab:hover {
+    border-color: #6f42c1;
+    background: #f3e8ff;
+}
+
+.docking-ligand-tab.active {
+    border-color: #6f42c1;
+    background: linear-gradient(135deg, #6f42c1 0%, #9b59b6 100%);
+    color: white;
+}
+
+.docking-ligand-tab .ligand-color-dot {
+    width: 12px;
+    height: 12px;
+    border-radius: 50%;
+    display: inline-block;
+}
+
+.docking-poses-viewer-wrapper {
+    position: relative;
+    margin-bottom: 15px;
+    max-width: 700px;
+    margin-left: auto;
+    margin-right: auto;
+}
+
+.docking-poses-viewer {
+    width: 100%;
+    max-width: 700px;
+    height: 500px;
+    background: #fff;
+    border-radius: 5px;
+    border: 2px solid #6f42c1;
+    overflow: hidden;
+    margin: 0 auto;
+}
+
+.pose-nav-controls {
+    position: absolute;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    gap: 20px;
+    padding: 15px;
+    background: linear-gradient(to top, rgba(255,255,255,0.95) 0%, rgba(255,255,255,0) 100%);
+    border-radius: 0 0 5px 5px;
+}
+
+.pose-nav-btn {
+    width: 50px;
+    height: 50px;
+    border-radius: 50%;
+    border: 2px solid #6f42c1;
+    background: white;
+    color: #6f42c1;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 1.2rem;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.15);
+}
+
+.pose-nav-btn:hover:not(:disabled) {
+    background: #6f42c1;
+    border-color: #6f42c1;
+    color: white;
+    transform: scale(1.1);
+}
+
+.pose-nav-btn:disabled {
+    opacity: 0.3;
+    cursor: not-allowed;
+}
+
+.pose-info-display {
+    text-align: center;
+    min-width: 200px;
+}
+
+.pose-mode-label {
+    font-size: 1.1rem;
+    font-weight: 600;
+    color: #333;
+}
+
+.pose-energy-label {
+    font-size: 0.95rem;
+    color: #28a745;
+    font-weight: 500;
+}
+
+.pose-color-legend {
+    display: flex;
+    gap: 20px;
+    justify-content: center;
+    margin-top: 8px;
+    font-size: 0.85rem;
+}
+
+.pose-color-legend span {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    color: #555;
+}
+
+.legend-dot {
+    width: 12px;
+    height: 12px;
+    border-radius: 50%;
+    display: inline-block;
+}
+
+.legend-dot.original {
+    background: #00ff00;
+}
+
+.legend-dot.docked {
+    background: #ff6b6b;
+}
+
+.docking-poses-selection {
+    background: #f8f9fa;
+    border-radius: 8px;
+    padding: 15px;
+    border: 1px solid #dee2e6;
+}
+
+.docking-poses-selection h5 {
+    margin-bottom: 10px;
+    color: #495057;
+    font-size: 0.95rem;
+}
+
+.pose-selection-row {
+    display: flex;
+    align-items: center;
+    gap: 15px;
+    padding: 10px;
+    background: white;
+    border-radius: 6px;
+    margin-bottom: 8px;
+    border: 1px solid #e9ecef;
+}
+
+.pose-selection-row:last-child {
+    margin-bottom: 0;
+}
+
+.pose-selection-label {
+    font-weight: 500;
+    min-width: 100px;
+}
+
+.pose-selection-options {
+    display: flex;
+    gap: 15px;
+    flex-wrap: wrap;
+}
+
+.pose-selection-option {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    cursor: pointer;
+    padding: 4px 8px;
+    border-radius: 4px;
+    transition: background 0.2s ease;
+}
+
+.pose-selection-option:hover {
+    background: #e9ecef;
+}
+
+.pose-selection-option input[type="radio"] {
+    accent-color: #6f42c1;
+}
+
+.pose-selection-option.selected {
+    background: #f3e8ff;
+    border: 1px solid #6f42c1;
+}
+
+.pose-selection-energy {
+    font-size: 0.85rem;
+    color: #28a745;
+    font-weight: 500;
+}

amberflow/docking.py

@@ -0,0 +1,54 @@
+# Step 1 obabel -i pdb ../4_ligands_corrected_1.pdb -o sdf -O ligand.sdf
+
+# Step 2 Run tleap on 1_protein_no_hydrogens.pdb to protonate and add hydrogen to the pdb file 
+# leap file content:
+# source leaprc.protein.ff14SB
+# protein = loadpdb 1_protein_no_hydrogens.pdb
+# savepdb protein protein.pdb
+# quit
+
+# Step 3 pdb4amber -i receptor.pdb -o receptor_fixed.pdb  run this command on protein to add element names 
+
+# Step 4 mk_prepare_ligand.py -i ligand.sdf -o ligand.pdbqt run this command on ligand to get pdbqt file for selected ligand
+
+# Step 4 mk_prepare_receptor.py -i receptor.pdb -o receptor -p   run this command on protein to get pdbqt file for selected protein chain
+
+# Now we are ready to run the docking 
+
+# find the center of the ligand
+# run this script 
+#from MDAnalysis import Universe
+#import numpy as np
+#
+#u = Universe("../output/4_ligands_corrected_1.pdb")
+#
+## replace 'LIG' with your ligand residue name
+#ligand = u.select_atoms("all")
+#coords = ligand.positions
+#
+## compute center of ligand
+#center = coords.mean(axis=0)
+#print("Center of ligand:", center)
+
+#then run this vina script 
+#vina \
+#  --receptor receptor_ready.pdbqt \
+#  --ligand ligand_1.pdbqt \
+#  --center_x 34.3124 \
+#  --center_y 4.95463 \
+#  --center_z 1.774217 \
+#  --size_x 18 \
+#  --size_y 18 \
+#  --size_z 18 \
+#  --out ligand_1_docked.pdbqt \
+#  --log ligand_1_docked.log
+
+#vina_split --input ligand_1_docked.pdbqt --ligand ligand_1_mode
+
+#Now we need to turn back pdbqt file to pdb file for ligand 
+#run this command to do that obabel ligand_1_mode1.pdbqt -O ligand_1_mode1.pdb -p 7.4 
+#now we need to add remaining hydrogens in it using pymol. pymol command is h_add ligand_1_mode1.pdb
+
+#Now we need to make sure the residue name is correct like the name in the original ligand and then 
+#we need to rename the atoms names to give this ligand to antechamber like C1, N1, .. like the way '4_ligands_corrected_1.pdb' formated 
+#Now this ligand is ready to be used by antechambe to generate force field parameters

amberflow/docking_utils.py

@@ -0,0 +1,639 @@
+#!/usr/bin/env python3
+"""
+Docking Utilities for AmberFlow
+
+This module contains all the Python functions needed for the docking workflow:
+1. Compute ligand center
+2. Prepare receptor (tleap + pdb4amber + meeko)
+3. Prepare ligand (obabel + meeko)
+4. Run Vina docking
+5. Split docked poses (vina_split)
+6. Convert poses to PDB (obabel)
+7. Sanitize docked poses for use in MD workflow
+
+Usage:
+    from docking_utils import (
+        compute_ligand_center,
+        prepare_receptor,
+        prepare_ligand,
+        run_vina_docking,
+        split_docked_poses,
+        convert_pdbqt_to_pdb,
+        sanitize_docked_pose
+    )
+"""
+
+import subprocess
+from pathlib import Path
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def compute_ligand_center(pdb_path: str) -> tuple:
+    """
+    Compute the geometric center of all atoms in a ligand PDB file.
+    
+    Args:
+        pdb_path: Path to the ligand PDB file
+        
+    Returns:
+        Tuple of (x, y, z) center coordinates
+    """
+    try:
+        import MDAnalysis as mda
+        import numpy as np
+    except ImportError as e:
+        raise RuntimeError(
+            "MDAnalysis and NumPy are required. Install with: "
+            "conda install -c conda-forge mdanalysis numpy"
+        ) from e
+    
+    pdb_path = Path(pdb_path)
+    if not pdb_path.exists():
+        raise FileNotFoundError(f"Ligand file not found: {pdb_path}")
+    
+    u = mda.Universe(str(pdb_path))
+    if u.atoms.n_atoms == 0:
+        raise ValueError(f"No atoms found in ligand file {pdb_path}")
+    
+    coords = u.atoms.positions.astype(float)
+    center = coords.mean(axis=0)
+    
+    logger.info(f"Ligand center for {pdb_path.name}: ({center[0]:.3f}, {center[1]:.3f}, {center[2]:.3f})")
+    return float(center[0]), float(center[1]), float(center[2])
+
+
+def prepare_receptor(protein_pdb: str, output_dir: str) -> tuple:
+    """
+    Prepare receptor for docking:
+    1. Run tleap to add hydrogens
+    2. Run pdb4amber to fix element names
+    3. Run mk_prepare_receptor.py to create PDBQT
+    
+    Args:
+        protein_pdb: Path to protein PDB file (typically 1_protein_no_hydrogens.pdb)
+        output_dir: Directory to store output files
+        
+    Returns:
+        Tuple of (receptor_fixed_pdb_path, receptor_pdbqt_path)
+    """
+    protein_pdb = Path(protein_pdb).resolve()
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    if not protein_pdb.exists():
+        raise FileNotFoundError(f"Protein PDB not found: {protein_pdb}")
+    
+    # Step 1: tleap - add hydrogens
+    tleap_in = output_dir / "prepare_receptor.in"
+    receptor_pdb = output_dir / "receptor.pdb"
+    
+    if not receptor_pdb.exists():
+        logger.info("Step 1: Running tleap to add hydrogens to protein...")
+        with open(tleap_in, "w") as f:
+            f.write("source leaprc.protein.ff14SB\n")
+            f.write(f"protein = loadpdb {protein_pdb}\n")
+            f.write("savepdb protein receptor.pdb\n")
+            f.write("quit\n")
+        
+        result = subprocess.run(
+            ["tleap", "-f", tleap_in.name],
+            cwd=output_dir,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0 or not receptor_pdb.exists():
+            raise RuntimeError(
+                f"tleap failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+            )
+        logger.info(f"  Created: {receptor_pdb}")
+    
+    # Step 2: pdb4amber - fix element names
+    receptor_fixed = output_dir / "receptor_fixed.pdb"
+    
+    if not receptor_fixed.exists():
+        logger.info("Step 2: Running pdb4amber to add element names...")
+        result = subprocess.run(
+            ["pdb4amber", "-i", str(receptor_pdb), "-o", str(receptor_fixed)],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0 or not receptor_fixed.exists():
+            raise RuntimeError(
+                f"pdb4amber failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+            )
+        logger.info(f"  Created: {receptor_fixed}")
+    
+    # Step 3: Meeko receptor preparation
+    receptor_pdbqt = output_dir / "receptor.pdbqt"
+    
+    if not receptor_pdbqt.exists():
+        logger.info("Step 3: Running mk_prepare_receptor.py to create PDBQT...")
+        result = subprocess.run(
+            ["mk_prepare_receptor.py", "-i", str(receptor_fixed), "-o", "receptor", "-p"],
+            cwd=output_dir,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0 or not receptor_pdbqt.exists():
+            raise RuntimeError(
+                f"mk_prepare_receptor.py failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+            )
+        logger.info(f"  Created: {receptor_pdbqt}")
+    
+    return str(receptor_fixed), str(receptor_pdbqt)
+
+
+def prepare_ligand(ligand_pdb: str, output_dir: str, ligand_index: int = 1) -> str:
+    """
+    Prepare ligand for docking:
+    1. Convert PDB to SDF using obabel
+    2. Convert SDF to PDBQT using mk_prepare_ligand.py
+    
+    Args:
+        ligand_pdb: Path to ligand PDB file
+        output_dir: Directory to store output files
+        ligand_index: Index number for naming output files
+        
+    Returns:
+        Path to ligand PDBQT file
+    """
+    ligand_pdb = Path(ligand_pdb)
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    if not ligand_pdb.exists():
+        raise FileNotFoundError(f"Ligand PDB not found: {ligand_pdb}")
+    
+    # Step 1: obabel PDB -> SDF
+    sdf_path = output_dir / f"ligand_{ligand_index}.sdf"
+    
+    logger.info(f"Step 1: Converting ligand {ligand_index} PDB to SDF...")
+    result = subprocess.run(
+        ["obabel", "-i", "pdb", str(ligand_pdb), "-o", "sdf", "-O", str(sdf_path)],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0 or not sdf_path.exists():
+        raise RuntimeError(
+            f"obabel failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+        )
+    logger.info(f"  Created: {sdf_path}")
+    
+    # Step 2: Meeko ligand preparation -> PDBQT
+    pdbqt_path = output_dir / f"ligand_{ligand_index}.pdbqt"
+    
+    logger.info(f"Step 2: Converting ligand {ligand_index} SDF to PDBQT...")
+    result = subprocess.run(
+        ["mk_prepare_ligand.py", "-i", str(sdf_path), "-o", str(pdbqt_path)],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0 or not pdbqt_path.exists():
+        raise RuntimeError(
+            f"mk_prepare_ligand.py failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+        )
+    logger.info(f"  Created: {pdbqt_path}")
+    
+    return str(pdbqt_path)
+
+
+def run_vina_docking(
+    receptor_pdbqt: str,
+    ligand_pdbqt: str,
+    center_x: float,
+    center_y: float,
+    center_z: float,
+    size_x: float = 18.0,
+    size_y: float = 18.0,
+    size_z: float = 18.0,
+    output_dir: str = None,
+    ligand_index: int = 1,
+    exhaustiveness: int = 8,
+    num_modes: int = 9,
+) -> tuple:
+    """
+    Run AutoDock Vina docking.
+    
+    Args:
+        receptor_pdbqt: Path to receptor PDBQT file
+        ligand_pdbqt: Path to ligand PDBQT file
+        center_x, center_y, center_z: Box center coordinates (Angstroms)
+        size_x, size_y, size_z: Box dimensions (Angstroms)
+        output_dir: Directory for output files (default: same as ligand)
+        ligand_index: Index for naming output files
+        exhaustiveness: Search exhaustiveness (default: 8)
+        num_modes: Maximum number of binding modes (default: 9)
+        
+    Returns:
+        Tuple of (docked_pdbqt_path, log_file_path)
+    """
+    ligand_pdbqt = Path(ligand_pdbqt)
+    output_dir = Path(output_dir) if output_dir else ligand_pdbqt.parent
+    
+    docked_pdbqt = output_dir / f"ligand_{ligand_index}_docked.pdbqt"
+    log_file = output_dir / f"ligand_{ligand_index}_docked.log"
+    
+    logger.info(f"Running Vina docking for ligand {ligand_index}...")
+    logger.info(f"  Center: ({center_x:.3f}, {center_y:.3f}, {center_z:.3f})")
+    logger.info(f"  Size: ({size_x:.1f}, {size_y:.1f}, {size_z:.1f})")
+    
+    cmd = [
+        "vina",
+        "--receptor", str(receptor_pdbqt),
+        "--ligand", str(ligand_pdbqt),
+        "--center_x", str(center_x),
+        "--center_y", str(center_y),
+        "--center_z", str(center_z),
+        "--size_x", str(size_x),
+        "--size_y", str(size_y),
+        "--size_z", str(size_z),
+        "--out", str(docked_pdbqt),
+        "--log", str(log_file),
+        "--exhaustiveness", str(exhaustiveness),
+        "--num_modes", str(num_modes),
+    ]
+    
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    
+    if result.returncode != 0 or not docked_pdbqt.exists():
+        raise RuntimeError(
+            f"Vina docking failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+        )
+    
+    logger.info(f"  Created: {docked_pdbqt}")
+    logger.info(f"  Log: {log_file}")
+    
+    return str(docked_pdbqt), str(log_file)
+
+
+def parse_vina_log(log_path: str) -> list:
+    """
+    Parse Vina log file to extract binding energies for each mode.
+    
+    Args:
+        log_path: Path to Vina log file
+        
+    Returns:
+        List of dicts with 'mode', 'affinity', 'rmsd_lb', 'rmsd_ub' for each pose
+    """
+    log_path = Path(log_path)
+    if not log_path.exists():
+        return []
+    
+    energies = []
+    in_results = False
+    
+    with open(log_path, "r") as f:
+        for line in f:
+            line = line.strip()
+            if "-----+------------+----------+----------" in line:
+                in_results = True
+                continue
+            if in_results and line and line[0].isdigit():
+                parts = line.split()
+                if len(parts) >= 4:
+                    try:
+                        energies.append({
+                            'mode': int(parts[0]),
+                            'affinity': float(parts[1]),
+                            'rmsd_lb': float(parts[2]),
+                            'rmsd_ub': float(parts[3]),
+                        })
+                    except (ValueError, IndexError):
+                        continue
+            elif in_results and not line:
+                break
+    
+    return energies
+
+
+def split_docked_poses(docked_pdbqt: str, output_prefix: str = None) -> list:
+    """
+    Split docked PDBQT into individual pose files using vina_split.
+    
+    Args:
+        docked_pdbqt: Path to docked PDBQT file with multiple poses
+        output_prefix: Prefix for output files (default: derived from input)
+        
+    Returns:
+        List of paths to individual pose PDBQT files
+    """
+    docked_pdbqt = Path(docked_pdbqt)
+    if not docked_pdbqt.exists():
+        raise FileNotFoundError(f"Docked PDBQT not found: {docked_pdbqt}")
+    
+    output_dir = docked_pdbqt.parent
+    if output_prefix is None:
+        output_prefix = docked_pdbqt.stem.replace("_docked", "_mode")
+    
+    logger.info(f"Splitting docked poses from {docked_pdbqt.name}...")
+    
+    result = subprocess.run(
+        ["vina_split", "--input", str(docked_pdbqt), "--ligand", output_prefix],
+        cwd=output_dir,
+        capture_output=True,
+        text=True,
+    )
+    
+    if result.returncode != 0:
+        raise RuntimeError(
+            f"vina_split failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+        )
+    
+    # Find all generated mode files
+    pose_files = sorted(output_dir.glob(f"{output_prefix}*.pdbqt"))
+    logger.info(f"  Split into {len(pose_files)} pose files")
+    
+    return [str(f) for f in pose_files]
+
+
+def convert_pdbqt_to_pdb(pdbqt_path: str, ph: float = 7.4) -> str:
+    """
+    Convert PDBQT file to PDB using obabel.
+    
+    Args:
+        pdbqt_path: Path to PDBQT file
+        ph: pH for protonation (default: 7.4)
+        
+    Returns:
+        Path to output PDB file
+    """
+    pdbqt_path = Path(pdbqt_path)
+    if not pdbqt_path.exists():
+        raise FileNotFoundError(f"PDBQT file not found: {pdbqt_path}")
+    
+    pdb_path = pdbqt_path.with_suffix(".pdb")
+    
+    logger.info(f"Converting {pdbqt_path.name} to PDB...")
+    
+    result = subprocess.run(
+        ["obabel", str(pdbqt_path), "-O", str(pdb_path), "-p", str(ph)],
+        capture_output=True,
+        text=True,
+    )
+    
+    if result.returncode != 0 or not pdb_path.exists():
+        raise RuntimeError(
+            f"obabel conversion failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+        )
+    
+    logger.info(f"  Created: {pdb_path}")
+    return str(pdb_path)
+
+
+def sanitize_docked_pose(original_ligand: str, pose_pdb: str) -> str:
+    """
+    Sanitize a docked pose PDB to match the original ligand format:
+    - Restore residue name, chain ID, and residue number from original
+    - Convert ATOM to HETATM
+    - Rename atoms to match original format (C1, N1, etc.)
+    - Remove CONECT/MASTER records
+    
+    Args:
+        original_ligand: Path to original ligand PDB file
+        pose_pdb: Path to docked pose PDB file
+        
+    Returns:
+        Path to sanitized pose PDB (same as pose_pdb, modified in place)
+    """
+    original_ligand = Path(original_ligand)
+    pose_pdb = Path(pose_pdb)
+    
+    if not original_ligand.exists():
+        raise FileNotFoundError(f"Original ligand not found: {original_ligand}")
+    if not pose_pdb.exists():
+        raise FileNotFoundError(f"Pose PDB not found: {pose_pdb}")
+    
+    # Extract residue info from original ligand
+    resname = "LIG"
+    chain = "X"
+    resnum = 1
+    
+    with open(original_ligand, "r") as f:
+        for line in f:
+            if line.startswith(("ATOM", "HETATM")):
+                resname = line[17:20].strip() or "LIG"
+                chain = line[21] if len(line) > 21 and line[21].strip() else "X"
+                try:
+                    resnum = int(line[22:26].strip())
+                except ValueError:
+                    resnum = 1
+                break
+    
+    logger.info(f"Sanitizing pose with resname={resname}, chain={chain}, resnum={resnum}")
+    
+    # Process pose PDB
+    new_lines = []
+    atom_counter = 0
+    element_counts = {}
+    
+    with open(pose_pdb, "r") as f:
+        for line in f:
+            if line.startswith(("CONECT", "MASTER")):
+                continue
+            if line.startswith(("ATOM", "HETATM")):
+                atom_counter += 1
+                
+                # Extract element from line or atom name
+                element = line[76:78].strip() if len(line) > 77 else ""
+                if not element:
+                    # Try to get from atom name
+                    atom_name = line[12:16].strip()
+                    element = ''.join(c for c in atom_name if c.isalpha())[:2]
+                    if len(element) > 1:
+                        element = element[0].upper() + element[1].lower()
+                
+                if not element:
+                    element = "C"  # Default fallback
+                
+                # Generate new atom name (C1, C2, N1, etc.)
+                element_counts[element] = element_counts.get(element, 0) + 1
+                new_atom_name = f"{element}{element_counts[element]}"
+                new_atom_name = f"{new_atom_name:<4}"  # Left-justified, 4 chars
+                
+                # Build new line as HETATM
+                new_line = (
+                    f"HETATM{atom_counter:5d} {new_atom_name}"
+                    f"{resname:>3s} {chain}{resnum:4d}    "
+                    f"{line[30:54]}"  # Coordinates
+                    f"{line[54:66] if len(line) > 54 else '  1.00  0.00'}"  # Occupancy, B-factor
+                    f"          {element:>2s}\n"
+                )
+                new_lines.append(new_line)
+            elif line.startswith("END"):
+                new_lines.append("END\n")
+    
+    # Write sanitized file
+    with open(pose_pdb, "w") as f:
+        f.writelines(new_lines)
+    
+    logger.info(f"  Sanitized: {pose_pdb}")
+    return str(pose_pdb)
+
+
+def run_full_docking_workflow(
+    protein_pdb: str,
+    ligand_pdbs: list,
+    output_dir: str,
+    box_configs: dict = None,
+) -> dict:
+    """
+    Run the complete docking workflow for multiple ligands.
+    
+    Args:
+        protein_pdb: Path to protein PDB file (1_protein_no_hydrogens.pdb)
+        ligand_pdbs: List of paths to ligand PDB files
+        output_dir: Base output directory for docking results
+        box_configs: Optional dict of {ligand_index: {'center': (x,y,z), 'size': (sx,sy,sz)}}
+        
+    Returns:
+        Dict with results for each ligand including poses and energies
+    """
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    box_configs = box_configs or {}
+    
+    results = {
+        'success': True,
+        'ligands': [],
+        'warnings': [],
+        'errors': [],
+    }
+    
+    # Step 1: Prepare receptor (only once for all ligands)
+    logger.info("=" * 60)
+    logger.info("STEP 1: Preparing receptor for docking")
+    logger.info("=" * 60)
+    
+    try:
+        receptor_fixed, receptor_pdbqt = prepare_receptor(protein_pdb, str(output_dir))
+    except Exception as e:
+        results['success'] = False
+        results['errors'].append(f"Receptor preparation failed: {str(e)}")
+        return results
+    
+    # Step 2: Process each ligand
+    for idx, ligand_pdb in enumerate(ligand_pdbs, start=1):
+        ligand_pdb = Path(ligand_pdb)
+        logger.info("")
+        logger.info("=" * 60)
+        logger.info(f"STEP 2.{idx}: Processing ligand {idx}: {ligand_pdb.name}")
+        logger.info("=" * 60)
+        
+        lig_dir = output_dir / f"ligand_{idx}"
+        lig_dir.mkdir(parents=True, exist_ok=True)
+        
+        ligand_result = {
+            'index': idx,
+            'original_file': str(ligand_pdb),
+            'poses': [],
+            'energies': [],
+            'success': True,
+        }
+        
+        try:
+            # Copy original ligand for reference
+            original_copy = lig_dir / "original_ligand.pdb"
+            if not original_copy.exists():
+                original_copy.write_text(ligand_pdb.read_text())
+            
+            # Prepare ligand PDBQT
+            ligand_pdbqt = prepare_ligand(str(ligand_pdb), str(lig_dir), idx)
+            
+            # Get box configuration
+            cfg = box_configs.get(idx, {})
+            center = cfg.get('center')
+            size = cfg.get('size', (18.0, 18.0, 18.0))
+            
+            if center is None:
+                # Compute center from ligand
+                cx, cy, cz = compute_ligand_center(str(ligand_pdb))
+            else:
+                cx, cy, cz = center
+            
+            sx, sy, sz = size
+            
+            # Run Vina docking
+            docked_pdbqt, log_file = run_vina_docking(
+                receptor_pdbqt, ligand_pdbqt,
+                cx, cy, cz, sx, sy, sz,
+                str(lig_dir), idx
+            )
+            
+            # Parse binding energies
+            energies = parse_vina_log(log_file)
+            ligand_result['energies'] = energies
+            
+            # Split poses
+            pose_pdbqts = split_docked_poses(docked_pdbqt)
+            
+            # Convert each pose to PDB and sanitize
+            for pose_pdbqt in pose_pdbqts:
+                pose_pdb = convert_pdbqt_to_pdb(pose_pdbqt)
+                sanitize_docked_pose(str(original_copy), pose_pdb)
+                ligand_result['poses'].append(pose_pdb)
+            
+        except Exception as e:
+            ligand_result['success'] = False
+            ligand_result['error'] = str(e)
+            results['errors'].append(f"Ligand {idx}: {str(e)}")
+            logger.error(f"Error processing ligand {idx}: {e}")
+        
+        results['ligands'].append(ligand_result)
+    
+    # Check overall success
+    results['success'] = all(lig['success'] for lig in results['ligands'])
+    
+    logger.info("")
+    logger.info("=" * 60)
+    logger.info("DOCKING WORKFLOW COMPLETE")
+    logger.info("=" * 60)
+    
+    return results
+
+
+# Example usage / CLI interface
+if __name__ == "__main__":
+    import argparse
+    
+    logging.basicConfig(level=logging.INFO, format='%(message)s')
+    
+    parser = argparse.ArgumentParser(description="Run AutoDock Vina docking workflow")
+    parser.add_argument("--protein", required=True, help="Path to protein PDB file")
+    parser.add_argument("--ligands", nargs="+", required=True, help="Paths to ligand PDB files")
+    parser.add_argument("--output", required=True, help="Output directory")
+    parser.add_argument("--center", nargs=3, type=float, help="Box center (x y z)")
+    parser.add_argument("--size", nargs=3, type=float, default=[18, 18, 18], help="Box size (x y z)")
+    
+    args = parser.parse_args()
+    
+    box_configs = {}
+    if args.center:
+        for i in range(1, len(args.ligands) + 1):
+            box_configs[i] = {
+                'center': tuple(args.center),
+                'size': tuple(args.size),
+            }
+    
+    results = run_full_docking_workflow(
+        args.protein,
+        args.ligands,
+        args.output,
+        box_configs
+    )
+    
+    print("\n" + "=" * 60)
+    print("RESULTS SUMMARY")
+    print("=" * 60)
+    print(f"Overall success: {results['success']}")
+    for lig in results['ligands']:
+        print(f"\nLigand {lig['index']}:")
+        print(f"  Success: {lig['success']}")
+        if lig['success']:
+            print(f"  Poses generated: {len(lig['poses'])}")
+            if lig['energies']:
+                print(f"  Best binding energy: {lig['energies'][0]['affinity']} kcal/mol")
+        else:
+            print(f"  Error: {lig.get('error', 'Unknown')}")

{html → amberflow/html}/index.html

@@ -5,7 +5,10 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>MD Simulation Pipeline</title>
     <link rel="stylesheet" href="../css/styles.css">
+    <link rel="stylesheet" href="../css/plumed.css">
     <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css" rel="stylesheet">
+    <!-- THREE.js (needed for docking box visualization) - using r95 to match NGL's bundled version -->
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r95/three.min.js"></script>
     <!-- NGL 3D Molecular Viewer -->
     <script src="https://unpkg.com/ngl@2.0.0-dev.35/dist/ngl.js"></script>
 </head>
@@ -24,6 +27,9 @@
             <button class="tab-button active" data-tab="protein-loading">
                 <i class="fas fa-upload"></i> Protein Loading
             </button>
+            <button class="tab-button" data-tab="fill-missing">
+                <i class="fas fa-puzzle-piece"></i> Fill Missing Residues
+            </button>
             <button class="tab-button" data-tab="structure-prep">
                 <i class="fas fa-tools"></i> Structure Preparation
             </button>
@@ -36,6 +42,9 @@
             <button class="tab-button" data-tab="file-generation">
                 <i class="fas fa-file-download"></i> Generate Files
             </button>
+            <button class="tab-button" data-tab="plumed">
+                <i class="fas fa-chart-line"></i> PLUMED
+            </button>
         </nav>
 
         <!-- Main Content -->
@@ -86,7 +95,7 @@
                         <div class="preview-content">
                             <div class="protein-info">
                                 <p><strong>Structure ID:</strong> <span id="structure-id"></span></p>
-                                <p><strong>Number of atoms:</strong> <span id="atom-count"></span></p>
+                                <p><strong>Number of atoms (Protein):</strong> <span id="atom-count"></span></p>
                                 <p><strong>Chains:</strong> <span id="chain-info"></span></p>
                                 <p><strong>Residues:</strong> <span id="residue-count"></span></p>
                                 <p><strong>Water molecules:</strong> <span id="water-count"></span></p>
@@ -116,6 +125,208 @@
                 </div>
             </div>
 
+            <!-- Fill Missing Residues Tab -->
+            <div id="fill-missing" class="tab-content">
+                <div class="card">
+                    <h2><i class="fas fa-puzzle-piece"></i> Fill Missing Residues</h2>
+                    <p class="card-description">
+                        Detect missing residues in the experimental structure using RCSB annotations and complete them
+                        with ESMFold. You can choose which chains to include in the completion.
+                    </p>
+                    <p class="form-text text-muted" style="margin-top: 6px; font-size: 0.9em;">
+                        <i class="fas fa-book"></i> If you use this workflow in your research, please cite: <a href="https://esmatlas.com/about" target="_blank" rel="noopener noreferrer">ESM Atlas</a>
+                    </p>
+
+                    <div class="prep-sections">
+                        <div class="prep-section">
+                            <h3><i class="fas fa-search"></i> Detect Missing Residues</h3>
+                            <button class="btn btn-primary" id="detect-missing-residues">
+                                <i class="fas fa-search"></i> Analyze Missing Residues
+                            </button>
+                            <div id="missing-status" class="status-message" style="margin-top: 10px;"></div>
+                        </div>
+
+                        <div class="prep-section" id="missing-chains-section" style="display: none;">
+                            <h3><i class="fas fa-link"></i> Select Chains for Completion</h3>
+                            <p class="option-description">
+                                Chains listed below have missing residues. Select which chains you want to rebuild with ESMFold.
+                            </p>
+                            <div id="missing-chains-list" class="multi-checkbox-group">
+                                <!-- Missing chains checkboxes will be rendered here -->
+                            </div>
+                            <small class="form-help">
+                                At least one chain must be selected to build a completed structure.
+                            </small>
+                        </div>
+                    </div>
+
+                    <div class="prep-section prep-section-fullwidth" id="trim-residues-section" style="display: none;">
+                        <h3><i class="fas fa-cut"></i> Trim Residues from Edges (Optional)</h3>
+                        <p class="option-description">
+                            Optionally trim residues from the N-terminal and/or C-terminal edges of selected chains. 
+                            This only removes residues from the edges, not from loops in between.
+                        </p>
+                        <div class="trim-info-box" id="trim-info-box-content">
+                            <i class="fas fa-info-circle"></i>
+                            <strong>Note:</strong> Only missing residues at the <strong>N-terminal edge</strong> (beginning of sequence) and <strong>C-terminal edge</strong> (end of sequence) can be trimmed. 
+                            Missing residues in internal loops (discontinuities in the middle of the sequence) cannot be trimmed using this tool and will be filled by ESMFold.
+                        </div>
+                        <div id="trim-residues-list" class="trim-residues-container">
+                            <!-- Trim controls for each chain will be rendered here -->
+                        </div>
+                        <button class="btn btn-secondary" id="apply-trim" style="margin-top: 15px;">
+                            <i class="fas fa-check"></i> Apply Trimming
+                        </button>
+                        <div id="trim-status" class="status-message" style="margin-top: 10px; display: none;"></div>
+                    </div>
+
+                    <!-- Chain Minimization Option -->
+                    <div class="prep-section" id="chain-minimization-section" style="display: none; margin-top: 20px; padding: 15px; background: #f8f9fa; border-radius: 5px; border: 1px solid #dee2e6;">
+                        <h3><i class="fas fa-compress-arrows-alt"></i> Energy Minimization (Optional)</h3>
+                        <div class="form-check" style="display: flex; align-items: center; gap: 10px; margin-top: 10px;">
+                            <input class="form-check-input" type="checkbox" id="minimize-chains-checkbox" style="width: 20px; height: 20px; cursor: pointer;">
+                            <label class="form-check-label" for="minimize-chains-checkbox" style="cursor: pointer; font-weight: 500; flex: 1;">
+                                <strong>Energy minimize ESMFold-generated chains</strong>
+                            </label>
+                        </div>
+                        <small class="form-text text-muted" style="display: block; margin-top: 8px; margin-left: 30px;">
+                            <i class="fas fa-info-circle"></i> Recommended: Minimization resolve structural clashes
+                        </small>
+                        <div id="minimization-chains-list" style="display: none; margin-top: 15px; margin-left: 30px;">
+                            <strong>Select chains to minimize:</strong>
+                            <div id="minimization-chains-checkboxes" class="multi-checkbox-group" style="margin-top: 10px;">
+                                <!-- Chain checkboxes will be populated here -->
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="prep-actions">
+                        <button class="btn btn-primary" id="build-complete-structure" disabled>
+                            <i class="fas fa-magic"></i> Build Completed Structure
+                        </button>
+                        <button class="btn btn-secondary" id="preview-completed-structure" disabled>
+                            <i class="fas fa-eye"></i> Preview Completed Structure
+                        </button>
+                        <button class="btn btn-secondary" id="preview-superimposed-structure" disabled>
+                            <i class="fas fa-layer-group"></i> View Superimposed Structures
+                        </button>
+                        <button class="btn btn-info" id="download-completed-structure" disabled>
+                            <i class="fas fa-download"></i> Download Completed PDB
+                        </button>
+                    </div>
+
+                    <div class="prep-status" id="missing-summary" style="display: none;">
+                        <h3><i class="fas fa-info-circle"></i> Missing Residues Summary</h3>
+                        <div class="status-content" id="missing-summary-content">
+                            <!-- Missing residues summary will be displayed here -->
+                        </div>
+                    </div>
+
+                    <div class="prep-actions" id="sequence-viewer-actions" style="display: none; margin-top: 1rem;">
+                        <button class="btn btn-secondary" id="view-protein-sequences">
+                            <i class="fas fa-dna"></i> View Protein Sequences
+                        </button>
+                    </div>
+
+                    <div class="prepared-structure-preview" id="sequence-viewer-section" style="display: none;">
+                        <h3><i class="fas fa-dna"></i> Protein Sequence Viewer</h3>
+                        <p class="card-description" style="margin-bottom: 15px;">
+                            View protein sequences for all chains. Chain colors match the structure visualization. Missing residues are shown in grey.
+                        </p>
+                        <div id="sequence-viewer-content" class="sequence-viewer-container">
+                            <!-- Sequence viewer will be rendered here -->
+                        </div>
+                    </div>
+
+                    <div class="prepared-structure-preview" id="completed-structure-preview" style="display: none;">
+                        <h3><i class="fas fa-eye"></i> Structure Comparison Preview</h3>
+                        <p class="card-description" style="margin-bottom: 15px;">
+                            Compare the completed structure (right) with the original crystal structure (left) to see the added missing residues.
+                        </p>
+                        <div class="preview-content" style="display: flex; justify-content: center; width: 100%; padding: 0;">
+                            <div class="structure-comparison-container" style="display: flex; gap: 20px; flex-direction: row; width: 100%; max-width: 1400px; align-items: flex-start; justify-content: center;">
+                                <!-- Original Structure Viewer -->
+                                <div class="comparison-viewer" style="flex: 0 1 48%; min-width: 450px; max-width: 48%;">
+                                    <h4 style="text-align: center; margin-bottom: 10px; font-size: 14px;">
+                                        <i class="fas fa-dna"></i> Original Crystal Structure
+                                    </h4>
+                                    <div id="original-molecule-viewer" class="molecule-viewer" style="border: 2px solid #007bff; border-radius: 5px; width: 100%; height: 500px; position: relative;">
+                                        <div id="original-ngl-viewer" style="width: 100%; height: 100%; position: absolute; top: 0; left: 0;"></div>
+                                        <div id="original-viewer-controls" class="viewer-controls" style="display: none; justify-content: center; position: relative; z-index: 10;">
+                                            <button class="btn btn-sm btn-secondary" onclick="mdPipeline.resetOriginalView()">
+                                                <i class="fas fa-home"></i> Reset
+                                            </button>
+                                            <button class="btn btn-sm btn-secondary" onclick="mdPipeline.toggleOriginalRepresentation()">
+                                                <i class="fas fa-eye"></i> <span id="original-style-text">Mixed</span>
+                                            </button>
+                                            <button class="btn btn-sm btn-secondary" onclick="mdPipeline.toggleOriginalSpin()">
+                                                <i class="fas fa-sync"></i> Spin
+                                            </button>
+                                        </div>
+                                    </div>
+                                </div>
+                                
+                                <!-- Completed Structure Viewer -->
+                                <div class="comparison-viewer" style="flex: 0 1 48%; min-width: 450px; max-width: 48%;">
+                                    <h4 style="text-align: center; margin-bottom: 10px; font-size: 14px;">
+                                        <i class="fas fa-puzzle-piece"></i> Completed Structure
+                                    </h4>
+                                    <div id="completed-molecule-viewer" class="molecule-viewer" style="border: 2px solid #28a745; border-radius: 5px; width: 100%; height: 500px; position: relative;">
+                                        <div id="completed-ngl-viewer" style="width: 100%; height: 100%; position: absolute; top: 0; left: 0;"></div>
+                                        <div id="completed-viewer-controls" class="viewer-controls" style="display: none; justify-content: center; position: relative; z-index: 10;">
+                                            <button class="btn btn-sm btn-secondary" onclick="mdPipeline.resetCompletedView()">
+                                                <i class="fas fa-home"></i> Reset
+                                            </button>
+                                            <button class="btn btn-sm btn-secondary" onclick="mdPipeline.toggleCompletedRepresentation()">
+                                                <i class="fas fa-eye"></i> <span id="completed-style-text">Mixed</span>
+                                            </button>
+                                            <button class="btn btn-sm btn-secondary" onclick="mdPipeline.toggleCompletedSpin()">
+                                                <i class="fas fa-sync"></i> Spin
+                                            </button>
+                                        </div>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="prepared-structure-preview" id="superimposed-structure-preview" style="display: none;">
+                        <h3><i class="fas fa-layer-group"></i> Superimposed Structure View</h3>
+                        <p class="card-description" style="margin-bottom: 15px;">
+                            View both the original crystal structure (original colors) and completed structure (different chain colors) superimposed in the same viewer to see which residues were filled.
+                        </p>
+                        <div class="preview-content" style="display: flex; justify-content: center; width: 100%; padding: 0;">
+                            <div class="structure-comparison-container" style="width: 100%; max-width: 1400px;">
+                                <!-- Superimposed Structure Viewer -->
+                                <div class="comparison-viewer" style="width: 100%;">
+                                    <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 10px;">
+                                        <div>
+                                            <span style="color: #007bff; font-weight: 600;"><i class="fas fa-dna"></i> Original Crystal Structure</span>
+                                            <span style="margin: 0 10px;">|</span>
+                                            <span style="color: #28a745; font-weight: 600;"><i class="fas fa-puzzle-piece"></i> Completed Structure</span>
+                                        </div>
+                                        <div id="superimposed-viewer-controls" class="viewer-controls" style="display: none; gap: 10px;">
+                                            <button class="btn btn-sm btn-secondary" onclick="mdPipeline.resetSuperimposedView()">
+                                                <i class="fas fa-home"></i> Reset
+                                            </button>
+                                            <button class="btn btn-sm btn-secondary" onclick="mdPipeline.toggleSuperimposedRepresentation()">
+                                                <i class="fas fa-eye"></i> <span id="superimposed-style-text">Cartoon</span>
+                                            </button>
+                                            <button class="btn btn-sm btn-secondary" onclick="mdPipeline.toggleSuperimposedSpin()">
+                                                <i class="fas fa-sync"></i> Spin
+                                            </button>
+                                        </div>
+                                    </div>
+                                    <div id="superimposed-molecule-viewer" class="molecule-viewer" style="border: 2px solid #007bff; border-radius: 5px; width: 100%; height: 600px; position: relative;">
+                                        <div id="superimposed-ngl-viewer" style="width: 100%; height: 100%; position: absolute; top: 0; left: 0;"></div>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
             <!-- Structure Preparation Tab -->
             <div id="structure-prep" class="tab-content">
                 <div class="card">
@@ -128,7 +339,7 @@
                             <div class="prep-options">
                                 <div class="prep-option">
                                     <label class="checkbox-container">
-                                        <input type="checkbox" id="remove-water" checked>
+                                        <input type="checkbox" id="remove-water" checked disabled>
                                         <span class="checkmark"></span>
                                         Remove water molecules
                                     </label>
@@ -137,7 +348,7 @@
                                 
                                 <div class="prep-option">
                                     <label class="checkbox-container">
-                                        <input type="checkbox" id="remove-ions" checked>
+                                        <input type="checkbox" id="remove-ions" checked disabled>
                                         <span class="checkmark"></span>
                                         Remove ions
                                     </label>
@@ -146,7 +357,7 @@
                                 
                                 <div class="prep-option">
                                     <label class="checkbox-container">
-                                        <input type="checkbox" id="remove-hydrogens" checked>
+                                        <input type="checkbox" id="remove-hydrogens" checked disabled>
                                         <span class="checkmark"></span>
                                         Remove hydrogen atoms
                                     </label>
@@ -247,8 +458,8 @@
                         <h3><i class="fas fa-eye"></i> Prepared Structure Preview</h3>
                         <div class="preview-content">
                             <div class="structure-info">
-                                <p><strong>Original atoms:</strong> <span id="original-atoms"></span></p>
-                                <p><strong>Prepared atoms:</strong> <span id="prepared-atoms"></span></p>
+                                <p><strong>Original atoms</strong> <span style="font-size:0.9em; color:#6c757d;">(protein without H, before capping):</span> <span id="original-atoms"></span></p>
+                                <p><strong>Prepared atoms</strong> <span style="font-size:0.9em; color:#6c757d;">(protein without H, after capping):</span> <span id="prepared-atoms"></span></p>
                                 <p><strong>Removed components:</strong> <span id="removed-components"></span></p>
                                 <p><strong>Added capping groups:</strong> <span id="added-capping"></span></p>
                                 <p><strong>Ligands preserved:</strong> <span id="preserved-ligands"></span></p>
@@ -271,6 +482,114 @@
                             </div>
                         </div>
                     </div>
+
+                    <!-- Docking Section (visible only when ligands are preserved and present) -->
+                    <div class="card plumed-section-card" id="docking-section" style="display: none; margin-top: 20px;">
+                        <h2 class="plumed-toggle-header" id="docking-toggle-header">
+                            <i class="fas fa-vial"></i> Ligand Docking
+                            <i class="fas fa-chevron-down toggle-icon" id="docking-toggle-icon"></i>
+                        </h2>
+                        <p class="section-description">
+                            Configure docking for preserved ligands using AutoDock Vina and Meeko. Select which ligands to dock,
+                            define the Vina bounding box with live visualization, then run docking and choose poses.
+                        </p>
+                        <div class="custom-plumed-section" id="docking-content-section">
+                            <!-- Ligand Selection -->
+                            <div class="form-group" style="margin-bottom: 20px;">
+                                <label><i class="fas fa-pills"></i> Select Ligands to Dock</label>
+                                <p class="option-description" style="margin-bottom: 10px;">
+                                    Choose which preserved ligands should be included in docking calculations.
+                                </p>
+                                <div id="docking-ligand-selection" class="multi-checkbox-group">
+                                    <!-- Ligand checkboxes will be rendered here -->
+                                </div>
+                            </div>
+
+                            <!-- Collapsible: Docking Setup (Visualization + Box Dimensions) -->
+                            <div class="docking-setup-collapsible" style="margin-top: 10px; border: 1px solid #dee2e6; border-radius: 8px; overflow: hidden;">
+                                <div class="docking-setup-header" id="docking-setup-toggle" style="background: linear-gradient(135deg, #6f42c1 0%, #8e5dd4 100%); color: white; padding: 12px 15px; cursor: pointer; display: flex; justify-content: space-between; align-items: center;">
+                                    <span><i class="fas fa-cube"></i> Docking Search Space Setup</span>
+                                    <i class="fas fa-chevron-up" id="docking-setup-toggle-icon" style="transition: transform 0.3s ease;"></i>
+                                </div>
+                                <div class="docking-setup-content" id="docking-setup-content" style="padding: 15px; background: white;">
+                                    <!-- Docking Search Space Visualization -->
+                                    <div class="prepared-structure-preview" id="docking-structure-preview">
+                                        <h4 style="margin-top: 0;"><i class="fas fa-eye"></i> Search Space Visualization</h4>
+                                        <p class="card-description" style="margin-bottom: 10px;">
+                                            The protein–ligand system is shown below. For each selected ligand, a bounding box (10×10×10 Å by default)
+                                            represents the Vina search space. Adjust box dimensions below to update the visualization live.
+                                        </p>
+                                        <!-- NGL Viewer - Matching section 2 aspect ratio -->
+                                        <div id="docking-ngl-viewer" class="molecule-viewer" style="border: 2px solid #6f42c1; border-radius: 5px; width: 100%; max-width: 700px; height: 500px; position: relative; margin: 0 auto;">
+                                            <!-- Docking NGL visualization will be added here -->
+                                        </div>
+                                    </div>
+                                    
+                                    <!-- Box Dimensions - Below Visualization -->
+                                    <div id="docking-box-controls" style="margin-top: 15px; background: #f8f9fa; padding: 15px; border-radius: 5px; border: 1px solid #dee2e6;">
+                                        <h5 style="margin-top: 0; margin-bottom: 15px;"><i class="fas fa-sliders-h"></i> Box Dimensions for Selected Ligands</h5>
+                                        <div id="docking-setup-list" style="display: flex; flex-wrap: wrap; gap: 15px;">
+                                            <!-- Per-ligand box controls will be rendered here in a horizontal layout -->
+                                        </div>
+                                    </div>
+
+                                    <div class="prep-actions" style="margin-top: 15px;">
+                                        <button class="btn btn-primary" id="run-docking">
+                                            <i class="fas fa-vial"></i> Run Docking with Above Settings
+                                        </button>
+                                    </div>
+                                </div>
+                            </div>
+                            <div id="docking-status" class="status-message" style="display: none; margin-top: 10px;"></div>
+                            
+                            <div id="docking-poses-container" style="display: none; margin-top: 20px;">
+                                <h4><i class="fas fa-project-diagram"></i> Visualize Binding Poses</h4>
+                                <p class="option-description">
+                                    Browse through docked poses for each ligand. Use the navigation arrows to view different binding modes.
+                                    Select your preferred pose for the simulation.
+                                </p>
+                                
+                                <!-- Ligand selector tabs -->
+                                <div id="docking-ligand-tabs" class="docking-ligand-tabs">
+                                    <!-- Ligand tabs will be rendered here -->
+                                </div>
+                                
+                                <!-- 3D Viewer with pose navigation -->
+                                <div class="docking-poses-viewer-wrapper">
+                                    <div id="docking-poses-viewer" class="docking-poses-viewer"></div>
+                                    
+                                    <!-- Pose navigation controls overlay -->
+                                    <div class="pose-nav-controls">
+                                        <button type="button" class="pose-nav-btn pose-nav-prev" id="pose-prev-btn" title="Previous Pose">
+                                            <i class="fas fa-chevron-left"></i>
+                                        </button>
+                                        <div class="pose-info-display">
+                                            <div class="pose-mode-label" id="pose-mode-label">Original Ligand</div>
+                                            <div class="pose-energy-label" id="pose-energy-label"></div>
+                                            <div class="pose-color-legend">
+                                                <span><span class="legend-dot original"></span> Original (green)</span>
+                                                <span><span class="legend-dot docked"></span> Docked (coral)</span>
+                                            </div>
+                                        </div>
+                                        <button type="button" class="pose-nav-btn pose-nav-next" id="pose-next-btn" title="Next Pose">
+                                            <i class="fas fa-chevron-right"></i>
+                                        </button>
+                                    </div>
+                                </div>
+                                
+                                <!-- Pose selection summary -->
+                                <div id="docking-poses-list" class="docking-poses-selection">
+                                    <!-- Radio buttons for final selection will be rendered here -->
+                                </div>
+                                
+                                <div class="prep-actions" style="margin-top: 15px;">
+                                    <button class="btn btn-success" id="apply-docking-poses">
+                                        <i class="fas fa-check"></i> Use Selected Pose
+                                    </button>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
                 </div>
             </div>
 
@@ -400,7 +719,7 @@
                             <div class="step-header">
                                 <h3><i class="fas fa-lock"></i> Restrained Minimization</h3>
                                 <label class="switch">
-                                    <input type="checkbox" id="enable-restrained-min" checked>
+                                    <input type="checkbox" id="enable-restrained-min" checked disabled>
                                     <span class="slider"></span>
                                 </label>
                             </div>
@@ -422,7 +741,7 @@
                             <div class="step-header">
                                 <h3><i class="fas fa-compress"></i> Minimization</h3>
                                 <label class="switch">
-                                    <input type="checkbox" id="enable-minimization" checked>
+                                    <input type="checkbox" id="enable-minimization" checked disabled>
                                     <span class="slider"></span>
                                 </label>
                             </div>
@@ -446,7 +765,7 @@
                             <div class="step-header">
                                 <h3><i class="fas fa-fire"></i> NPT Heating</h3>
                                 <label class="switch">
-                                    <input type="checkbox" id="enable-nvt" checked>
+                                    <input type="checkbox" id="enable-nvt" checked disabled>
                                     <span class="slider"></span>
                                 </label>
                             </div>
@@ -468,7 +787,7 @@
                             <div class="step-header">
                                 <h3><i class="fas fa-compress-arrows-alt"></i> NPT Equilibration</h3>
                                 <label class="switch">
-                                    <input type="checkbox" id="enable-npt" checked>
+                                    <input type="checkbox" id="enable-npt" checked disabled>
                                     <span class="slider"></span>
                                 </label>
                             </div>
@@ -494,7 +813,7 @@
                             <div class="step-header">
                                 <h3><i class="fas fa-play"></i> Production Run(NPT)</h3>
                                 <label class="switch">
-                                    <input type="checkbox" id="enable-production" checked>
+                                    <input type="checkbox" id="enable-production" checked disabled>
                                     <span class="slider"></span>
                                 </label>
                             </div>
@@ -521,6 +840,14 @@
 
             <!-- File Generation Tab -->
             <div id="file-generation" class="tab-content">
+                <!-- Guidance Note Card -->
+                <div class="plumed-citation-note">
+                    <i class="fas fa-info-circle"></i>
+                    <div class="citation-content">
+                        <p>Click on <strong>Generate All Files</strong>. If you want to run <strong>biased simulations</strong> using PLUMED, proceed to the <strong>next section (PLUMED)</strong> to configure collective variables. Otherwise, download all files here and you're all set!</p>
+                    </div>
+                </div>
+                
                 <div class="card">
                     <h2><i class="fas fa-file-download"></i> Generate Simulation Files</h2>
                     
@@ -534,10 +861,18 @@
                         <button class="btn btn-info" id="preview-solvated">
                             <i class="fas fa-tint"></i> Preview Solvated Protein
                         </button>
+                        <button class="btn btn-success" id="download-solvated">
+                            <i class="fas fa-download"></i> Download Solvated Protein
+                        </button>
                     </div>
 
                     <div class="files-preview" id="files-preview" style="display: none;">
-                        <h3><i class="fas fa-files"></i> Generated Files</h3>
+                        <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 15px;">
+                            <h3 style="margin: 0;"><i class="fas fa-files"></i> Generated Files</h3>
+                            <button class="btn btn-primary" id="add-simulation-file" style="margin-left: 10px;">
+                                <i class="fas fa-plus"></i> Add Simulation File
+                            </button>
+                        </div>
                         <div class="files-list" id="files-list">
                             <!-- Generated files will be listed here -->
                         </div>
@@ -561,6 +896,206 @@
                     </div>
                 </div>
             </div>
+            
+            <!-- PLUMED Section -->
+            <div id="plumed" class="tab-content">
+                <!-- PLUMED Citation Note -->
+                <div class="plumed-citation-note">
+                    <i class="fas fa-info-circle"></i>
+                    <div class="citation-content">
+                        <p><strong>Note:</strong> All CVs are taken from <a href="https://www.plumed.org/doc-v2.9/user-doc/html/index.html" target="_blank" rel="noopener noreferrer"><strong>PLUMED v2.9</strong> <i class="fas fa-external-link-alt"></i></a> documentation.</p>
+                        <p>If you use PLUMED in your research, please cite it. <a href="https://www.plumed.org/cite" target="_blank" rel="noopener noreferrer">Citation information <i class="fas fa-external-link-alt"></i></a></p>
+                    </div>
+                </div>
+                
+                <!-- PLUMED Collective Variables Section -->
+                <div class="card plumed-section-card">
+                    <h2>
+                        <i class="fas fa-chart-line"></i> PLUMED Collective Variables
+                    </h2>
+                    <p class="section-description">
+                        Configure Collective Variables (CVs) for biased MD simulations. Select a CV from the sidebar to view documentation and examples.
+                    </p>
+                    
+                    <div class="plumed-container" id="plumed-container">
+                        <!-- Left Sidebar: CV List -->
+                        <div class="plumed-sidebar">
+                            <div class="sidebar-header">
+                                <h3><i class="fas fa-list"></i> Collective Variables</h3>
+                                <div class="search-box">
+                                    <input type="text" id="cv-search" placeholder="Search CVs..." class="search-input">
+                                    <i class="fas fa-search search-icon"></i>
+                                </div>
+                            </div>
+                            <div class="cv-list" id="cv-list">
+                                <!-- CV items will be populated by JavaScript -->
+                            </div>
+                        </div>
+                        
+                        <!-- Right Panel: Documentation and Editor -->
+                        <div class="plumed-content">
+                            <div class="content-header" id="content-header" style="display: none;">
+                                <h3 id="cv-title"></h3>
+                            </div>
+                            
+                            <div class="content-body" id="content-body">
+                                <div class="welcome-message" id="welcome-message">
+                                    <i class="fas fa-hand-pointer fa-3x"></i>
+                                    <h3>Select a Collective Variable</h3>
+                                    <p>Choose a CV from the left sidebar to view its documentation and configure it for your simulation.</p>
+                                </div>
+                                
+                                <!-- Documentation Section -->
+                                <div class="cv-documentation" id="cv-documentation" style="display: none;">
+                                    <div class="doc-section" id="cv-module-section" style="display: none;">
+                                        <h4><i class="fas fa-puzzle-piece"></i> Module</h4>
+                                        <div class="doc-content" id="cv-module"></div>
+                                    </div>
+                                    
+                                    <div class="doc-section">
+                                        <h4><i class="fas fa-info-circle"></i> Description</h4>
+                                        <div class="doc-content" id="cv-description"></div>
+                                    </div>
+                                    
+                                    <div class="doc-section">
+                                        <h4><i class="fas fa-code"></i> Syntax</h4>
+                                        <div class="doc-content">
+                                            <pre class="syntax-box" id="cv-syntax"></pre>
+                                        </div>
+                                    </div>
+                                    
+                                    <div class="doc-section" id="cv-glossary-section" style="display: none;">
+                                        <h4><i class="fas fa-book"></i> Glossary of keywords and components</h4>
+                                        <div class="doc-content" id="cv-glossary"></div>
+                                    </div>
+                                    
+                                    <div class="doc-section" id="cv-options-section" style="display: none;">
+                                        <h4><i class="fas fa-list-ul"></i> Options</h4>
+                                        <div class="doc-content" id="cv-options"></div>
+                                    </div>
+                                    
+                                    <div class="doc-section" id="cv-components-section" style="display: none;">
+                                        <h4><i class="fas fa-cogs"></i> Components</h4>
+                                        <div class="doc-content" id="cv-components"></div>
+                                    </div>
+                                    
+                                    <div class="doc-section">
+                                        <h4><i class="fas fa-book"></i> Examples</h4>
+                                        <div class="doc-content">
+                                            <pre class="example-box" id="cv-example"></pre>
+                                        </div>
+                                    </div>
+                                    
+                                    <div class="doc-section" id="cv-notes-section" style="display: none;">
+                                        <h4><i class="fas fa-sticky-note"></i> Notes</h4>
+                                        <div class="doc-content" id="cv-notes"></div>
+                                    </div>
+                                    
+                                    <div class="doc-section" id="cv-related-section" style="display: none;">
+                                        <h4><i class="fas fa-link"></i> Related Collective Variables</h4>
+                                        <div class="doc-content" id="cv-related"></div>
+                                    </div>
+                                </div>
+                                
+                                <!-- Editable Editor Section -->
+                                <div class="cv-editor-section" id="cv-editor-section" style="display: none;">
+                                    <div class="editor-header">
+                                        <h4><i class="fas fa-edit"></i> Your Configuration</h4>
+                                        <div class="editor-actions">
+                                            <button class="btn btn-sm btn-info" id="copy-config">
+                                                <i class="fas fa-copy"></i> Copy
+                                            </button>
+                                            <button class="btn btn-sm btn-primary" id="view-pdb">
+                                                <i class="fas fa-eye"></i> View PDB
+                                            </button>
+                                            <button class="btn btn-sm btn-secondary" id="reset-cv">
+                                                <i class="fas fa-redo"></i> Reset to Example
+                                            </button>
+                                            <button class="btn btn-sm btn-success" id="save-config">
+                                                <i class="fas fa-save"></i> Save
+                                            </button>
+                                        </div>
+                                    </div>
+                                    <textarea id="cv-editor" class="cv-editor" placeholder="Enter your PLUMED configuration here..."></textarea>
+                                    <div class="editor-footer">
+                                        <span class="char-count"><span id="char-count">0</span> characters</span>
+                                        <span class="line-count"><span id="line-count">0</span> lines</span>
+                                    </div>
+                                </div>
+                                
+                                <!-- Saved Configurations -->
+                                <div class="saved-configs" id="saved-configs" style="display: none;">
+                                    <h4><i class="fas fa-bookmark"></i> Saved Configurations</h4>
+                                    <div class="configs-list" id="configs-list">
+                                        <!-- Saved configs will be shown here -->
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+                
+                <!-- Custom PLUMED File Section -->
+                <div class="card plumed-section-card" id="custom-plumed-card">
+                    <h2 class="plumed-toggle-header" id="custom-plumed-toggle-header">
+                        <i class="fas fa-file-code"></i> Write Custom PLUMED File
+                        <i class="fas fa-chevron-down toggle-icon" id="custom-plumed-toggle-icon"></i>
+                    </h2>
+                    <p class="section-description">
+                        Write your custom PLUMED configuration from scratch. This editor allows you to create a complete PLUMED input file.
+                    </p>
+                    
+                    <div class="custom-plumed-section" id="custom-plumed-section">
+                        <div class="custom-editor-header">
+                            <h4><i class="fas fa-edit"></i> Custom PLUMED Configuration</h4>
+                            <div class="editor-actions">
+                                <button class="btn btn-sm btn-info" id="copy-custom-plumed">
+                                    <i class="fas fa-copy"></i> Copy
+                                </button>
+                                <button class="btn btn-sm btn-primary" id="view-pdb-custom">
+                                    <i class="fas fa-eye"></i> View PDB
+                                </button>
+                                <button class="btn btn-sm btn-success" id="download-custom-plumed">
+                                    <i class="fas fa-save"></i> Save
+                                </button>
+                                <button class="btn btn-sm btn-secondary" id="clear-custom-plumed">
+                                    <i class="fas fa-trash"></i> Clear
+                                </button>
+                            </div>
+                        </div>
+                        <textarea id="custom-plumed-editor" class="custom-plumed-editor" placeholder="Write your PLUMED configuration here...&#10;&#10;Example:&#10;# PLUMED input file&#10;d1: DISTANCE ATOMS=1,2&#10;PRINT ARG=d1 FILE=colvar.dat"></textarea>
+                        <div class="editor-footer">
+                            <span class="char-count"><span id="custom-char-count">0</span> characters</span>
+                            <span class="line-count"><span id="custom-line-count">0</span> lines</span>
+                        </div>
+                    </div>
+                </div>
+                
+                <!-- Generate Simulation Files Section -->
+                <div class="card plumed-section-card" id="generate-simulation-files-card">
+                    <h2 class="plumed-toggle-header" id="generate-simulation-files-toggle-header">
+                        <i class="fas fa-cogs"></i> Generate Simulation Files
+                        <i class="fas fa-chevron-down toggle-icon" id="generate-simulation-files-toggle-icon"></i>
+                    </h2>
+                    <p class="section-description">
+                        Generate and download simulation files for your PLUMED setup.
+                    </p>
+                    
+                    <div class="generate-simulation-files-section" id="generate-simulation-files-section">
+                        <div class="generation-controls" style="display: flex; gap: 10px; padding: 20px;">
+                            <button class="btn btn-primary" id="plumed-generate-files">
+                                <i class="fas fa-magic"></i> Generate Files
+                            </button>
+                            <button class="btn btn-secondary" id="plumed-preview-files">
+                                <i class="fas fa-eye"></i> Preview Files
+                            </button>
+                            <button class="btn btn-success" id="plumed-download-files">
+                                <i class="fas fa-download"></i> Download Files
+                            </button>
+                        </div>
+                    </div>
+                </div>
+            </div>
         </main>
         
         <!-- Step Navigation Controls -->
@@ -569,7 +1104,7 @@
                 <i class="fas fa-chevron-left"></i> Previous
             </button>
             <div class="step-indicator">
-                <span id="current-step">1</span> of <span id="total-steps">5</span>
+                <span id="current-step">1</span> of <span id="total-steps">7</span>
             </div>
             <button class="nav-btn next-btn" id="next-tab">
                 Next <i class="fas fa-chevron-right"></i>
@@ -582,6 +1117,29 @@
         </footer>
     </div>
 
+        <!-- PDB Viewer Modal -->
+        <div class="modal" id="pdb-viewer-modal" style="display: none; position: fixed; top: 0; left: 0; width: 100%; height: 100%; background: rgba(0,0,0,0.5); z-index: 10000; overflow: auto;">
+            <div class="modal-content" style="max-width: 90%; max-height: 90vh; margin: 5vh auto; background: white; border-radius: 8px; box-shadow: 0 4px 6px rgba(0,0,0,0.1);">
+                <div class="modal-header" style="display: flex; justify-content: space-between; align-items: center; padding: 15px; border-bottom: 1px solid #ddd; background: #f8f9fa; border-radius: 8px 8px 0 0;">
+                    <h3 style="margin: 0;"><i class="fas fa-file-code"></i> Viewer PDB File</h3>
+                    <button class="btn btn-sm btn-secondary" id="close-pdb-modal" style="margin: 0;">
+                        <i class="fas fa-times"></i> Close
+                    </button>
+                </div>
+                <div class="modal-body" style="padding: 15px; overflow: auto; max-height: calc(90vh - 100px);">
+                    <div id="pdb-content-loading" style="text-align: center; padding: 20px;">
+                        <i class="fas fa-spinner fa-spin"></i> Loading PDB file...
+                    </div>
+                    <div id="pdb-content-error" style="display: none; color: #dc3545; padding: 20px; text-align: center;">
+                        <i class="fas fa-exclamation-triangle"></i> <span id="pdb-error-message"></span>
+                    </div>
+                    <pre id="pdb-content" style="display: none; font-family: 'Courier New', monospace; font-size: 12px; line-height: 1.4; background: #f8f9fa; padding: 15px; border-radius: 4px; overflow-x: auto; white-space: pre-wrap; word-wrap: break-word;"></pre>
+                </div>
+            </div>
+    </div>
+
     <script src="../js/script.js"></script>
+    <script src="../js/plumed_cv_docs.js"></script>
+    <script src="../js/plumed.js"></script>
 </body>
 </html>

amberflow/html/plumed.html

@@ -0,0 +1,99 @@
+<!-- PLUMED Collective Variables Section -->
+<div id="plumed" class="tab-content">
+    <div class="card">
+        <h2><i class="fas fa-chart-line"></i> PLUMED Collective Variables</h2>
+        <p class="section-description">
+            Configure Collective Variables (CVs) for biased MD simulations. Select a CV from the sidebar to view documentation and examples.
+        </p>
+        
+        <div class="plumed-container">
+            <!-- Left Sidebar: CV List -->
+            <div class="plumed-sidebar">
+                <div class="sidebar-header">
+                    <h3><i class="fas fa-list"></i> Collective Variables</h3>
+                    <div class="search-box">
+                        <input type="text" id="cv-search" placeholder="Search CVs..." class="search-input">
+                        <i class="fas fa-search search-icon"></i>
+                    </div>
+                </div>
+                <div class="cv-list" id="cv-list">
+                    <!-- CV items will be populated by JavaScript -->
+                </div>
+            </div>
+            
+            <!-- Right Panel: Documentation and Editor -->
+            <div class="plumed-content">
+                <div class="content-header" id="content-header" style="display: none;">
+                    <h3 id="cv-title"></h3>
+                    <button class="btn btn-sm btn-secondary" id="reset-cv">
+                        <i class="fas fa-redo"></i> Reset to Example
+                    </button>
+                </div>
+                
+                <div class="content-body" id="content-body">
+                    <div class="welcome-message" id="welcome-message">
+                        <i class="fas fa-hand-pointer fa-3x"></i>
+                        <h3>Select a Collective Variable</h3>
+                        <p>Choose a CV from the left sidebar to view its documentation and configure it for your simulation.</p>
+                    </div>
+                    
+                    <!-- Documentation Section -->
+                    <div class="cv-documentation" id="cv-documentation" style="display: none;">
+                        <div class="doc-section">
+                            <h4><i class="fas fa-info-circle"></i> Description</h4>
+                            <div class="doc-content" id="cv-description"></div>
+                        </div>
+                        
+                        <div class="doc-section">
+                            <h4><i class="fas fa-code"></i> Syntax</h4>
+                            <div class="doc-content">
+                                <pre class="syntax-box" id="cv-syntax"></pre>
+                            </div>
+                        </div>
+                        
+                        <div class="doc-section">
+                            <h4><i class="fas fa-book"></i> Example</h4>
+                            <div class="doc-content">
+                                <pre class="example-box" id="cv-example"></pre>
+                            </div>
+                        </div>
+                        
+                        <div class="doc-section" id="cv-components-section" style="display: none;">
+                            <h4><i class="fas fa-cogs"></i> Components</h4>
+                            <div class="doc-content" id="cv-components"></div>
+                        </div>
+                    </div>
+                    
+                    <!-- Editable Editor Section -->
+                    <div class="cv-editor-section" id="cv-editor-section" style="display: none;">
+                        <div class="editor-header">
+                            <h4><i class="fas fa-edit"></i> Your Configuration</h4>
+                            <div class="editor-actions">
+                                <button class="btn btn-sm btn-info" id="copy-config">
+                                    <i class="fas fa-copy"></i> Copy
+                                </button>
+                                <button class="btn btn-sm btn-success" id="save-config">
+                                    <i class="fas fa-save"></i> Save
+                                </button>
+                            </div>
+                        </div>
+                        <textarea id="cv-editor" class="cv-editor" placeholder="Enter your PLUMED configuration here..."></textarea>
+                        <div class="editor-footer">
+                            <span class="char-count"><span id="char-count">0</span> characters</span>
+                            <span class="line-count"><span id="line-count">0</span> lines</span>
+                        </div>
+                    </div>
+                    
+                    <!-- Saved Configurations -->
+                    <div class="saved-configs" id="saved-configs" style="display: none;">
+                        <h4><i class="fas fa-bookmark"></i> Saved Configurations</h4>
+                        <div class="configs-list" id="configs-list">
+                            <!-- Saved configs will be shown here -->
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+

{python → amberflow}/structure_preparation.py

@@ -4,10 +4,16 @@ AMBER Structure Preparation Script using MDAnalysis
 Complete pipeline: extract protein, add caps, handle ligands
 """
 
+import glob
 import os
+import re
 import subprocess
 import sys
 import shutil
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
 
 def run_command(cmd, description=""):
     """Run a command and return success status"""
@@ -44,7 +50,8 @@ def extract_protein_only(pdb_content, output_file, selected_chains=None):
             chain_filters = ' or '.join([f'chain {c}' for c in selected_chains])
             chain_sel = f' and ({chain_filters})'
         selection = f"protein{chain_sel} and not name H* 1H* 2H* 3H*"
-        cmd = f'python -c "import MDAnalysis as mda; u=mda.Universe(\'{output_file}\'); u.select_atoms(\'{selection}\').write(\'{output_file}\')"'
+        abspath = os.path.abspath(output_file)
+        cmd = f'python -c "import MDAnalysis as mda; u=mda.Universe(\'{abspath}\'); u.select_atoms(\'{selection}\').write(\'{abspath}\')"'
         result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=60)
         
         if result.returncode != 0:
@@ -57,9 +64,10 @@ def extract_protein_only(pdb_content, output_file, selected_chains=None):
 
 def add_capping_groups(input_file, output_file):
     """Add ACE and NME capping groups using add_caps.py"""
+    add_caps_script = (Path(__file__).resolve().parent / "add_caps.py")
     # First add caps
     temp_capped = output_file.replace('.pdb', '_temp.pdb')
-    cmd = f"python add_caps.py -i {input_file} -o {temp_capped}"
+    cmd = f"python {add_caps_script} -i {input_file} -o {temp_capped}"
     if not run_command(cmd, f"Adding capping groups to {input_file}"):
         return False
     
@@ -74,6 +82,52 @@ def add_capping_groups(input_file, output_file):
     
     return True
 
+
+def replace_chain_in_pdb(target_pdb, chain_id, source_pdb):
+    """
+    Replace a specific chain in target_pdb with the chain from source_pdb.
+    Only performs replacement if the target actually contains the chain_id.
+    Used to merge ESMFold-minimized chains into 1_protein_no_hydrogens.pdb.
+    If the source has no ATOM lines (or none matching the chain), we do NOT
+    modify the target, to avoid wiping the protein when the minimized file is
+    empty or has an unexpected format.
+    """
+    with open(target_pdb, 'r') as f:
+        target_lines = f.readlines()
+    if not any(
+        ln.startswith(('ATOM', 'HETATM')) and len(ln) >= 22 and ln[21] == chain_id
+        for ln in target_lines
+    ):
+        return
+    with open(source_pdb, 'r') as f:
+        source_lines = f.readlines()
+    source_chain_lines = []
+    for ln in source_lines:
+        if ln.startswith(('ATOM', 'HETATM')) and len(ln) >= 22:
+            ch = ln[21]
+            if ch == 'A' or ch == chain_id:
+                source_chain_lines.append(ln[:21] + chain_id + ln[22:])
+    if not source_chain_lines:
+        # Fallback: minimized PDB may use chain ' ' or other; take all ATOM/HETATM.
+        for ln in source_lines:
+            if ln.startswith(('ATOM', 'HETATM')) and len(ln) >= 22:
+                source_chain_lines.append(ln[:21] + chain_id + ln[22:])
+    if not source_chain_lines:
+        return  # Do not modify target: we have nothing to add; avoid wiping the protein.
+    filtered_target = [
+        ln for ln in target_lines
+        if not (ln.startswith(('ATOM', 'HETATM')) and len(ln) >= 22 and ln[21] == chain_id)
+    ]
+    combined = []
+    for ln in filtered_target:
+        if ln.startswith('END'):
+            combined.extend(source_chain_lines)
+            combined.append("TER\n")
+        combined.append(ln)
+    with open(target_pdb, 'w') as f:
+        f.writelines(combined)
+
+
 def extract_selected_chains(pdb_content, output_file, selected_chains):
     """Extract selected chains using PyMOL commands"""
     try:
@@ -111,20 +165,29 @@ pymol.cmd.quit()
         return False
 
 def extract_selected_ligands(pdb_content, output_file, selected_ligands):
-    """Extract selected ligands using PyMOL commands"""
+    """Extract selected ligands using PyMOL commands.
+    selected_ligands: list of dicts with resn, chain, and optionally resi.
+    When resi is provided, use (resn X and chain Y and resi Z) to uniquely pick
+    one instance when the same ligand (resn) appears multiple times in the same chain.
+    """
     try:
         # Write input content to temp file
         temp_input = output_file.replace('.pdb', '_temp_input.pdb')
         with open(temp_input, 'w') as f:
             f.write(pdb_content)
         
-        # Build ligand selection string
+        # Build ligand selection string (include resi when present to disambiguate duplicates)
         parts = []
         for lig in selected_ligands:
             resn = lig.get('resn', '').strip()
             chain = lig.get('chain', '').strip()
+            resi = lig.get('resi') if lig.get('resi') is not None else ''
+            resi = str(resi).strip() if resi else ''
             if resn and chain:
-                parts.append(f"(resn {resn} and chain {chain})")
+                if resi:
+                    parts.append(f"(resn {resn} and chain {chain} and resi {resi})")
+                else:
+                    parts.append(f"(resn {resn} and chain {chain})")
             elif resn:
                 parts.append(f"resn {resn}")
         
@@ -169,13 +232,22 @@ def extract_ligands(pdb_content, output_file, ligand_residue_name=None, selected
     try:
         # Run MDAnalysis command with the output file as input
         if selected_ligands:
-            # Build selection from provided ligand list (RESN-CHAIN groups)
+            # Build selection from provided ligand list; include resid when present to disambiguate
+            # when the same ligand (resn) appears multiple times in the same chain (GOL-A-1, GOL-A-2)
             parts = []
             for lig in selected_ligands:
                 resn = lig.get('resn', '').strip()
                 chain = lig.get('chain', '').strip()
+                resi = lig.get('resi') if lig.get('resi') is not None else ''
+                resi = str(resi).strip() if resi else ''
                 if resn and chain:
-                    parts.append(f"(resname {resn} and segid {chain})")
+                    if resi:
+                        # Extract leading digits for resid in case of insertion codes (e.g. 100A -> 100)
+                        m = re.search(r'^(-?\d+)', resi)
+                        resid_val = m.group(1) if m else resi
+                        parts.append(f"(resname {resn} and segid {chain} and resid {resid_val})")
+                    else:
+                        parts.append(f"(resname {resn} and segid {chain})")
                 elif resn:
                     parts.append(f"resname {resn}")
             if parts:
@@ -255,46 +327,305 @@ def convert_atom_to_hetatm(pdb_file):
         print(f"Error converting ATOM to HETATM: {e}")
         return False
 
-def correct_ligand_with_pymol(ligand_file, corrected_file):
-    """Correct ligand using PyMOL"""
+def extract_original_residue_info(ligand_file):
+    """Extract original residue name, chain ID, and residue number from ligand PDB file"""
+    residue_info = {}
+    try:
+        with open(ligand_file, 'r') as f:
+            for line in f:
+                if line.startswith(('ATOM', 'HETATM')):
+                    resname = line[17:20].strip()
+                    chain_id = line[21:22].strip()
+                    resnum = line[22:26].strip()
+                    # Store the first residue info we find (assuming single residue per file)
+                    if resname and resname not in residue_info:
+                        residue_info = {
+                            'resname': resname,
+                            'chain_id': chain_id,
+                            'resnum': resnum
+                        }
+                        break  # We only need the first residue info
+        return residue_info
+    except Exception as e:
+        print(f"Error extracting residue info: {e}")
+        return {}
+
+def restore_residue_info_in_pdb(pdb_file, original_resname, original_chain_id, original_resnum):
+    """Restore original residue name, chain ID, and residue number in PDB file"""
+    try:
+        with open(pdb_file, 'r') as f:
+            lines = f.readlines()
+        
+        restored_lines = []
+        for line in lines:
+            if line.startswith(('ATOM', 'HETATM')):
+                # Restore residue name (columns 17-20)
+                restored_line = line[:17] + f"{original_resname:>3}" + line[20:]
+                # Restore chain ID (column 21)
+                if original_chain_id:
+                    restored_line = restored_line[:21] + original_chain_id + restored_line[22:]
+                # Restore residue number (columns 22-26)
+                if original_resnum:
+                    restored_line = restored_line[:22] + f"{original_resnum:>4}" + restored_line[26:]
+                restored_lines.append(restored_line)
+            elif line.startswith('MASTER'):
+                # Skip MASTER records
+                continue
+            else:
+                restored_lines.append(line)
+        
+        with open(pdb_file, 'w') as f:
+            f.writelines(restored_lines)
+        
+        print(f"Restored residue info: {original_resname} {original_chain_id} {original_resnum} in {pdb_file}")
+        return True
+    except Exception as e:
+        print(f"Error restoring residue info: {e}")
+        return False
+
+def correct_ligand_with_openbabel(ligand_file, corrected_file):
+    """Correct ligand using OpenBabel (add hydrogens at pH 7.4) and preserve original residue info"""
     ligand_path = os.path.abspath(ligand_file)
     corrected_path = os.path.abspath(corrected_file)
     if not os.path.isfile(ligand_path) or os.path.getsize(ligand_path) == 0:
         print("Ligand file missing or empty:", ligand_path)
         return False
 
-    # Use PyMOL to add hydrogens and save corrected ligand
-    cmd = f'pymol -cq {ligand_path} -d "h_add; save {corrected_path}; quit"'
-    return run_command(cmd, f"Correcting ligand with PyMOL")
+    # Extract original residue info before OpenBabel processing
+    residue_info = extract_original_residue_info(ligand_path)
+    original_resname = residue_info.get('resname', 'UNL')
+    original_chain_id = residue_info.get('chain_id', '')
+    original_resnum = residue_info.get('resnum', '1')
+    
+    print(f"Original residue info: {original_resname} {original_chain_id} {original_resnum}")
+
+    # Use OpenBabel to add hydrogens at pH 7.4
+    cmd = f'obabel -i pdb {ligand_path} -o pdb -O {corrected_path} -p 7.4'
+    success = run_command(cmd, f"Correcting ligand with OpenBabel")
+    
+    if not success:
+        return False
+    
+    # Restore original residue name, chain ID, and residue number
+    if residue_info:
+        restore_residue_info_in_pdb(corrected_path, original_resname, original_chain_id, original_resnum)
+    
+    return True
+
+def split_ligands_by_residue(ligand_file, output_dir):
+    """Split multi-ligand PDB file into individual ligand files using MDAnalysis (one file per residue)
+    This is more robust than splitting by TER records as it properly handles residue-based splitting.
+    """
+    ligand_files = []
+    try:
+        ligand_path = os.path.abspath(ligand_file)
+        output_dir_abs = os.path.abspath(output_dir)
+        
+        # Use MDAnalysis to split ligands by residue - this is the robust method
+        # Command: python -c "import MDAnalysis as mda; u=mda.Universe('3_ligands_extracted.pdb'); [res.atoms.write(f'3_ligand_extracted_{i}.pdb') for i,res in enumerate(u.residues,1)]"
+        cmd = f'''python -c "import MDAnalysis as mda; import os; u=mda.Universe('{ligand_path}'); os.chdir('{output_dir_abs}'); [res.atoms.write(f'3_ligand_extracted_{{i}}.pdb') for i,res in enumerate(u.residues,1)]"'''
+        
+        print(f"Running MDAnalysis command to split ligands by residue...")
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True, cwd=output_dir_abs)
+        
+        if result.returncode != 0:
+            print(f"Error running MDAnalysis command: {result.stderr}")
+            print(f"Command output: {result.stdout}")
+            return []
+        
+        # Collect all generated ligand files
+        ligand_files = []
+        for f in os.listdir(output_dir):
+            if f.startswith('3_ligand_extracted_') and f.endswith('.pdb'):
+                ligand_files.append(os.path.join(output_dir, f))
+        
+        # Sort by number in filename (e.g., 3_ligand_extracted_1.pdb, 3_ligand_extracted_2.pdb, ...)
+        ligand_files.sort(key=lambda x: int(os.path.basename(x).split('_')[-1].split('.')[0]))
+        
+        print(f"Split {len(ligand_files)} ligand(s) from {ligand_file}")
+        return ligand_files
+    except Exception as e:
+        print(f"Error splitting ligands: {e}")
+        import traceback
+        traceback.print_exc()
+        return []
 
 def remove_connect_records(pdb_file):
-    """Remove CONNECT records from PDB file"""
+    """Remove CONNECT and MASTER records from PDB file"""
     try:
         with open(pdb_file, 'r') as f:
             lines = f.readlines()
         
-        # Filter out CONNECT records
-        filtered_lines = [line for line in lines if not line.startswith('CONECT')]
+        # Filter out CONNECT and MASTER records
+        filtered_lines = [line for line in lines if not line.startswith(('CONECT', 'MASTER'))]
         
         with open(pdb_file, 'w') as f:
             f.writelines(filtered_lines)
         
-        print(f"Removed CONNECT records from {pdb_file}")
+        print(f"Removed CONNECT and MASTER records from {pdb_file}")
         return True
     except Exception as e:
-        print(f"Error removing CONNECT records: {e}")
+        print(f"Error removing CONNECT/MASTER records: {e}")
         return False
 
-def merge_protein_and_ligand(protein_file, ligand_file, output_file):
-    """Merge capped protein and corrected ligand with proper PDB formatting"""
+def convert_atom_to_hetatm_in_ligand(pdb_file):
+    """Convert ATOM records to HETATM in ligand PDB file for consistency"""
+    try:
+        with open(pdb_file, 'r') as f:
+            lines = f.readlines()
+        
+        converted_lines = []
+        converted_count = 0
+        for line in lines:
+            if line.startswith('ATOM'):
+                # Replace ATOM with HETATM, preserving the rest of the line
+                converted_line = 'HETATM' + line[6:]
+                converted_lines.append(converted_line)
+                converted_count += 1
+            else:
+                converted_lines.append(line)
+        
+        with open(pdb_file, 'w') as f:
+            f.writelines(converted_lines)
+        
+        if converted_count > 0:
+            print(f"Converted {converted_count} ATOM record(s) to HETATM in {pdb_file}")
+        
+        return True
+    except Exception as e:
+        print(f"Error converting ATOM to HETATM: {e}")
+        return False
+
+def make_atom_names_distinct(pdb_file):
+    """Make all atom names distinct (C1, C2, O1, O2, H1, H2, etc.) for antechamber compatibility
+    Antechamber requires each atom to have a unique name.
+    """
+    try:
+        from collections import defaultdict
+        
+        with open(pdb_file, 'r') as f:
+            lines = f.readlines()
+        
+        # Track counts for each element type
+        element_counts = defaultdict(int)
+        modified_lines = []
+        modified_count = 0
+        
+        for line in lines:
+            if line.startswith(('ATOM', 'HETATM')):
+                # Extract element from the last field (column 76-78) or from atom name (columns 12-16)
+                # Try to get element from the last field first (more reliable)
+                element = line[76:78].strip()
+                
+                # If element not found in last field, try to extract from atom name
+                if not element:
+                    atom_name = line[12:16].strip()
+                    # Extract element symbol (first letter, or first two letters for two-letter elements)
+                    if len(atom_name) >= 1:
+                        # Check for two-letter elements (common ones: Cl, Br, etc.)
+                        if len(atom_name) >= 2 and atom_name[:2].upper() in ['CL', 'BR', 'MG', 'CA', 'ZN', 'FE', 'MN', 'CU', 'NI', 'CO', 'CD', 'HG', 'PB', 'SR', 'BA', 'RB', 'CS', 'LI']:
+                            element = atom_name[:2].upper()
+                        else:
+                            element = atom_name[0].upper()
+                
+                # Increment count for this element
+                element_counts[element] += 1
+                count = element_counts[element]
+                
+                # Create distinct atom name: Element + number (e.g., C1, C2, O1, O2, H1, H2)
+                # Atom name is in columns 12-16 (4 characters, right-aligned)
+                distinct_name = f"{element}{count}"
+                
+                # Ensure the name fits in 4 characters (right-aligned)
+                if len(distinct_name) > 4:
+                    # For long element names, use abbreviation or truncate
+                    if element == 'CL':
+                        distinct_name = f"Cl{count}"[:4]
+                    elif element == 'BR':
+                        distinct_name = f"Br{count}"[:4]
+                    else:
+                        distinct_name = distinct_name[:4]
+                
+                # Replace atom name (columns 12-16, right-aligned)
+                modified_line = line[:12] + f"{distinct_name:>4}" + line[16:]
+                modified_lines.append(modified_line)
+                modified_count += 1
+            else:
+                modified_lines.append(line)
+        
+        with open(pdb_file, 'w') as f:
+            f.writelines(modified_lines)
+        
+        if modified_count > 0:
+            print(f"Made {modified_count} atom name(s) distinct in {pdb_file}")
+            print(f"Element counts: {dict(element_counts)}")
+        
+        return True
+    except Exception as e:
+        print(f"Error making atom names distinct: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def sanity_check_ligand_pdb(pdb_file):
+    """Perform sanity checks on ligand PDB file after OpenBabel processing:
+    1. Remove CONECT and MASTER records
+    2. Convert ATOM records to HETATM for consistency
+    3. Make all atom names distinct (C1, C2, O1, O2, H1, H2, etc.) for antechamber compatibility
+    """
+    try:
+        # Step 1: Remove CONECT and MASTER records
+        if not remove_connect_records(pdb_file):
+            return False
+        
+        # Step 2: Convert ATOM to HETATM for consistency
+        if not convert_atom_to_hetatm_in_ligand(pdb_file):
+            return False
+        
+        # Step 3: Make atom names distinct (required by antechamber)
+        if not make_atom_names_distinct(pdb_file):
+            return False
+        
+        print(f"Sanity check completed for {pdb_file}")
+        return True
+    except Exception as e:
+        print(f"Error in sanity check: {e}")
+        return False
+
+def merge_protein_and_ligand(protein_file, ligand_file, output_file, ligand_lines_list=None, ligand_groups=None):
+    """Merge capped protein and corrected ligand(s) with proper PDB formatting
+    
+    Args:
+        protein_file: Path to protein PDB file
+        ligand_file: Path to ligand PDB file (optional, if ligand_lines_list or ligand_groups is provided)
+        output_file: Path to output merged PDB file
+        ligand_lines_list: List of ligand lines (optional, for backward compatibility - single ligand)
+        ligand_groups: List of ligand line groups, where each group is a list of lines for one ligand (for multiple ligands with TER separation)
+    """
     try:
         # Read protein file
         with open(protein_file, 'r') as f:
             protein_lines = f.readlines()
         
-        # Read ligand file
-        with open(ligand_file, 'r') as f:
-            ligand_lines = f.readlines()
+        # Get ligand lines - prioritize ligand_groups for multiple ligands
+        if ligand_groups is not None:
+            # Multiple ligands: each group will be separated by TER
+            ligand_groups_processed = ligand_groups
+        elif ligand_lines_list is not None:
+            # Single ligand: wrap in a list for consistent processing
+            ligand_groups_processed = [ligand_lines_list] if ligand_lines_list else []
+        elif ligand_file:
+            # Read ligand file
+            with open(ligand_file, 'r') as f:
+                ligand_lines = f.readlines()
+            # Process ligand file: remove header info (CRYST, REMARK, etc.) and keep only ATOM/HETATM
+            ligand_processed = []
+            for line in ligand_lines:
+                if line.startswith(('ATOM', 'HETATM')):
+                    ligand_processed.append(line)
+            ligand_groups_processed = [ligand_processed] if ligand_processed else []
+        else:
+            ligand_groups_processed = []
         
         # Process protein file: remove 'END' and add properly formatted 'TER'
         protein_processed = []
@@ -317,14 +648,29 @@ def merge_protein_and_ligand(protein_file, ligand_file, output_file):
                 if line.startswith('ATOM'):
                     last_atom_line = line
         
-        # Process ligand file: remove header info (CRYST, REMARK, etc.) and keep only ATOM/HETATM
-        ligand_processed = []
-        for line in ligand_lines:
-            if line.startswith(('ATOM', 'HETATM')):
-                ligand_processed.append(line)
+        # Combine ligands with TER records between each ligand
+        ligand_content = []
+        for i, ligand_group in enumerate(ligand_groups_processed):
+            if ligand_group:  # Only process non-empty groups
+                # Add ligand atoms
+                ligand_content.extend(ligand_group)
+                # Add TER record after each ligand (except the last one, which will be followed by END)
+                if i < len(ligand_groups_processed) - 1:
+                    # Get last atom info from current ligand group to create TER
+                    if ligand_group:
+                        last_ligand_atom = ligand_group[-1]
+                        if last_ligand_atom.startswith(('ATOM', 'HETATM')):
+                            atom_num = last_ligand_atom[6:11].strip()
+                            res_name = last_ligand_atom[17:20].strip()
+                            chain_id = last_ligand_atom[21:22].strip()
+                            res_num = last_ligand_atom[22:26].strip()
+                            ter_line = f"TER    {atom_num:>5}      {res_name} {chain_id}{res_num}\n"
+                            ligand_content.append(ter_line)
+                        else:
+                            ligand_content.append('TER\n')
         
-        # Combine: protein + TER + ligand + END (no extra newline between TER and ligand)
-        merged_content = ''.join(protein_processed) + ''.join(ligand_processed) + 'END\n'
+        # Combine: protein + TER + ligand(s) with TER between ligands + END
+        merged_content = ''.join(protein_processed) + ''.join(ligand_content) + 'END\n'
         
         with open(output_file, 'w') as f:
             f.write(merged_content)
@@ -332,6 +678,8 @@ def merge_protein_and_ligand(protein_file, ligand_file, output_file):
         return True
     except Exception as e:
         print(f"Error merging files: {str(e)}")
+        import traceback
+        traceback.print_exc()
         return False
 
 def prepare_structure(pdb_content, options, output_dir="output"):
@@ -341,7 +689,19 @@ def prepare_structure(pdb_content, options, output_dir="output"):
         os.makedirs(output_dir, exist_ok=True)
         
         # Define all file paths in output directory
-        input_file = os.path.join(output_dir, "0_original_input.pdb")
+        # Prefer the superimposed completed structure (0_complete_structure.pdb) when it
+        # exists: it has ESMFold/minimized chains aligned to the original frame so that
+        # ligands stay in the same coordinate frame throughout the pipeline.
+        complete_structure_file = os.path.join(output_dir, "0_complete_structure.pdb")
+        original_input_file = os.path.join(output_dir, "0_original_input.pdb")
+        
+        if os.path.exists(complete_structure_file):
+            input_file = complete_structure_file
+            logger.info("Using superimposed completed structure (0_complete_structure.pdb) as input for coordinate-frame consistency with ligands")
+        else:
+            input_file = original_input_file
+            logger.info("Using original input (0_original_input.pdb) as input")
+        
         user_chain_file = os.path.join(output_dir, "0_user_chain_selected.pdb")
         protein_file = os.path.join(output_dir, "1_protein_no_hydrogens.pdb")
         protein_capped_file = os.path.join(output_dir, "2_protein_with_caps.pdb")
@@ -349,10 +709,22 @@ def prepare_structure(pdb_content, options, output_dir="output"):
         ligand_corrected_file = os.path.join(output_dir, "4_ligands_corrected.pdb")
         tleap_ready_file = os.path.join(output_dir, "tleap_ready.pdb")
         
-        # Step 0: Save original input for reference
-        print("Step 0: Saving original input...")
-        with open(input_file, 'w') as f:
-            f.write(pdb_content)
+        # Step 0: Save original input for reference (only if using original input)
+        # If using completed structure, we don't overwrite it
+        if input_file == original_input_file:
+            print("Step 0: Saving original input...")
+            with open(input_file, 'w') as f:
+                f.write(pdb_content)
+        else:
+            # If using completed structure, read it instead of using pdb_content
+            print("Step 0: Using completed structure as input...")
+            with open(input_file, 'r') as f:
+                pdb_content = f.read()
+            # Also save a reference to original input if it doesn't exist
+            if not os.path.exists(original_input_file):
+                print("Step 0: Saving reference to original input...")
+                with open(original_input_file, 'w') as f:
+                    f.write(pdb_content)
         
         # Step 0.5: Extract user-selected chains and ligands
         selected_chains = options.get('selected_chains', [])
@@ -367,7 +739,12 @@ def prepare_structure(pdb_content, options, output_dir="output"):
             shutil.copy2(input_file, user_chain_file)
         
         if selected_ligands:
-            ligand_names = [f"{l.get('resn', '')}-{l.get('chain', '')}" for l in selected_ligands]
+            ligand_names = []
+            for l in selected_ligands:
+                s = f"{l.get('resn', '')}-{l.get('chain', '')}"
+                if l.get('resi'):
+                    s += f" (resi {l.get('resi')})"
+                ligand_names.append(s)
             print(f"Step 0.5b: Extracting selected ligands: {ligand_names}")
             if not extract_selected_ligands(pdb_content, ligand_file, selected_ligands):
                 raise Exception("Failed to extract selected ligands")
@@ -385,6 +762,20 @@ def prepare_structure(pdb_content, options, output_dir="output"):
         if not extract_protein_only(chain_content, protein_file):
             raise Exception("Failed to extract protein")
         
+        # Step 1b: Merge minimized chains into 1_protein_no_hydrogens.pdb only when the
+        # input is NOT 0_complete_structure. When we use 0_complete_structure, it was
+        # built by rebuild_pdb_with_esmfold, which already incorporates and superimposes
+        # the minimized chains; the raw *_esmfold_minimized_noH.pdb files are in the
+        # minimization frame, so merging them here would break the coordinate frame.
+        if input_file != complete_structure_file:
+            for path in glob.glob(os.path.join(output_dir, "*_chain_*_esmfold_minimized_noH.pdb")):
+                name = os.path.basename(path).replace(".pdb", "")
+                parts = name.split("_chain_")
+                if len(parts) == 2:
+                    chain_id = parts[1].split("_")[0]
+                    replace_chain_in_pdb(protein_file, chain_id, path)
+                    logger.info("Merged minimized chain %s into 1_protein_no_hydrogens.pdb", chain_id)
+        
         # Step 2: Add capping groups (only if add_ace or add_nme is True)
         add_ace = options.get('add_ace', True)
         add_nme = options.get('add_nme', True)
@@ -402,6 +793,23 @@ def prepare_structure(pdb_content, options, output_dir="output"):
         # Step 3: Handle ligands (use pre-extracted ligand file)
         preserve_ligands = options.get('preserve_ligands', True)
         ligand_present = False
+        ligand_count = 0
+        selected_ligand_count = 0  # Store count from selected_ligands separately
+        
+        # Count selected ligands if provided (before processing)
+        if selected_ligands:
+            # Count unique ligand entities (by residue name, chain, and residue number)
+            unique_ligands = set()
+            for lig in selected_ligands:
+                resn = str(lig.get('resn') or '')
+                chain = str(lig.get('chain') or '')
+                resi = str(lig.get('resi') or '')
+                # Create unique identifier (resi disambiguates when same resn+chain appears multiple times)
+                unique_id = f"{resn}_{chain}_{resi}"
+                unique_ligands.add(unique_id)
+            selected_ligand_count = len(unique_ligands)
+            ligand_count = selected_ligand_count  # Initialize with selected count
+            print(f"Found {selected_ligand_count} unique selected ligand(s)")
         
         if preserve_ligands:
             print("Step 3: Processing pre-extracted ligands...")
@@ -414,23 +822,72 @@ def prepare_structure(pdb_content, options, output_dir="output"):
                 ligand_present = True
                 print("Found pre-extracted ligands")
                 
-                # Correct ligand with PyMOL
-                if not correct_ligand_with_pymol(ligand_file, ligand_corrected_file):
-                    print("Error: Failed to process ligand")
-                    return {
-                        'error': 'Failed to process ligand with PyMOL',
-                        'prepared_structure': '',
-                        'original_atoms': 0,
-                        'prepared_atoms': 0,
-                        'removed_components': {},
-                        'added_capping': {},
-                        'preserved_ligands': 0,
-                        'ligand_present': False
-                    }
+                # Split ligands into individual files using MDAnalysis (by residue)
+                individual_ligand_files = split_ligands_by_residue(ligand_file, output_dir)
+                # Update ligand_count based on actual split results if not already set from selected_ligands
+                if not selected_ligands or len(individual_ligand_files) != ligand_count:
+                    ligand_count = len(individual_ligand_files)
+                    print(f"Split into {ligand_count} individual ligand file(s)")
                 
-                # Merge protein and ligand
-                if not merge_protein_and_ligand(protein_capped_file, ligand_corrected_file, tleap_ready_file):
-                    raise Exception("Failed to merge protein and ligand")
+                if ligand_count == 0:
+                    print("Warning: No ligands could be extracted from file")
+                    shutil.copy2(protein_capped_file, tleap_ready_file)
+                else:
+                    print(f"Processing {ligand_count} ligand(s) individually...")
+                    
+                    # Process each ligand: OpenBabel -> sanity check -> final corrected file
+                    corrected_ligand_files = []
+                    for i, individual_file in enumerate(individual_ligand_files, 1):
+                        # OpenBabel output file (intermediate, kept for reference)
+                        obabel_file = os.path.join(output_dir, f"4_ligands_corrected_obabel_{i}.pdb")
+                        # Final corrected file (after sanity checks)
+                        corrected_file = os.path.join(output_dir, f"4_ligands_corrected_{i}.pdb")
+                        
+                        # Use OpenBabel to add hydrogens (write to obabel_file)
+                        if not correct_ligand_with_openbabel(individual_file, obabel_file):
+                            print(f"Error: Failed to process ligand {i} with OpenBabel")
+                            continue
+                        
+                        # Copy obabel file to corrected file before sanity check
+                        shutil.copy2(obabel_file, corrected_file)
+                        
+                        # Perform sanity check on corrected_file: remove CONECT/MASTER, convert ATOM to HETATM, make names distinct
+                        if not sanity_check_ligand_pdb(corrected_file):
+                            print(f"Warning: Sanity check failed for ligand {i}, but continuing...")
+                        
+                        corrected_ligand_files.append(corrected_file)
+                    
+                    if not corrected_ligand_files:
+                        print("Error: Failed to process any ligands")
+                        return {
+                            'error': 'Failed to process ligands with OpenBabel',
+                            'prepared_structure': '',
+                            'original_atoms': 0,
+                            'prepared_atoms': 0,
+                            'removed_components': {},
+                            'added_capping': {},
+                            'preserved_ligands': 0,
+                            'ligand_present': False
+                        }
+                    
+                    # Merge all corrected ligands into a single file for tleap_ready
+                    # Read all corrected ligand files and group them by ligand (for TER separation)
+                    all_ligand_groups = []
+                    for corrected_lig_file in corrected_ligand_files:
+                        with open(corrected_lig_file, 'r') as f:
+                            lig_lines = [line for line in f if line.startswith(('ATOM', 'HETATM'))]
+                            if lig_lines:  # Only add non-empty ligand groups
+                                all_ligand_groups.append(lig_lines)
+                    
+                    # Merge protein and all ligands (with TER records between ligands)
+                    if not merge_protein_and_ligand(protein_capped_file, None, tleap_ready_file, ligand_groups=all_ligand_groups):
+                        raise Exception("Failed to merge protein and ligands")
+            elif selected_ligands and ligand_count > 0:
+                # If ligands were selected but file is empty, still mark as present if we have a count
+                ligand_present = True
+                print(f"Ligands were selected ({ligand_count} unique), but ligand file appears empty")
+                # Use protein only since no ligand content found
+                shutil.copy2(protein_capped_file, tleap_ready_file)
             else:
                 print("No ligands found in pre-extracted file, using protein only")
                 # Copy protein file to tleap_ready
@@ -441,11 +898,25 @@ def prepare_structure(pdb_content, options, output_dir="output"):
             # Copy protein file to tleap_ready (protein only, no ligands)
             shutil.copy2(protein_capped_file, tleap_ready_file)
         
+        # Ensure tleap_ready.pdb exists before proceeding
+        if not os.path.exists(tleap_ready_file):
+            print(f"Error: tleap_ready.pdb was not created. Checking what went wrong...")
+            # Try to create it from protein_capped_file as fallback
+            if os.path.exists(protein_capped_file):
+                print("Creating tleap_ready.pdb from protein_capped_file as fallback...")
+                shutil.copy2(protein_capped_file, tleap_ready_file)
+            else:
+                raise Exception(f"tleap_ready.pdb was not created and protein_capped_file also doesn't exist")
+        
         # Remove CONNECT records from tleap_ready.pdb (PyMOL adds them)
         print("Removing CONNECT records from tleap_ready.pdb...")
-        remove_connect_records(tleap_ready_file)
+        if not remove_connect_records(tleap_ready_file):
+            print("Warning: Failed to remove CONNECT records, but continuing...")
         
         # Read the final prepared structure
+        if not os.path.exists(tleap_ready_file):
+            raise Exception("tleap_ready.pdb does not exist after processing")
+        
         with open(tleap_ready_file, 'r') as f:
             prepared_content = f.read()
             
@@ -499,12 +970,32 @@ def prepare_structure(pdb_content, options, output_dir="output"):
                     'nme_groups': 0
                 }
             
-            # Count preserved ligands from the pre-extracted file
-            preserved_ligands = 0
-            if ligand_present and preserve_ligands:
-                with open(ligand_file, 'r') as f:
-                    ligand_lines = [line for line in f if line.startswith('HETATM')]
-                preserved_ligands = len(set(line[17:20].strip() for line in ligand_lines))
+            # Count preserved ligands
+            # Priority: 1) selected_ligands count, 2) processed ligand_count, 3) 0
+            if preserve_ligands:
+                if selected_ligand_count > 0:
+                    # Use count from selected_ligands (most reliable)
+                    preserved_ligands = selected_ligand_count
+                    print(f"Using selected ligand count: {preserved_ligands}")
+                elif ligand_present and ligand_count > 0:
+                    # Use count from processing
+                    preserved_ligands = ligand_count
+                    print(f"Using processed ligand count: {preserved_ligands}")
+                elif ligand_present:
+                    # Ligands were present but count is 0, try to count from tleap_ready
+                    # Count unique ligand residue names in tleap_ready.pdb
+                    ligand_resnames = set()
+                    for line in prepared_content.split('\n'):
+                        if line.startswith('HETATM'):
+                            resname = line[17:20].strip()
+                            if resname and resname not in ['HOH', 'WAT', 'TIP', 'SPC', 'NA', 'CL', 'ACE', 'NME']:
+                                ligand_resnames.add(resname)
+                    preserved_ligands = len(ligand_resnames)
+                    print(f"Counted {preserved_ligands} unique ligand residue name(s) from tleap_ready.pdb")
+                else:
+                    preserved_ligands = 0
+            else:
+                preserved_ligands = 0
             
             result = {
                 'prepared_structure': prepared_content,

js/script.js

@@ -1,2004 +0,0 @@
-// MD Simulation Pipeline JavaScript
-console.log('Script loading...'); // Debug log
-
-class MDSimulationPipeline {
-    constructor() {
-        this.currentProtein = null;
-        this.preparedProtein = null;
-        this.simulationParams = {};
-        this.generatedFiles = {};
-        this.nglStage = null;
-        this.preparedNglStage = null;
-        this.currentRepresentation = 'cartoon';
-        this.preparedRepresentation = 'cartoon';
-        this.isSpinning = false;
-        this.preparedIsSpinning = false;
-        this.currentTabIndex = 0;
-        this.tabOrder = ['protein-loading', 'structure-prep', 'simulation-params', 'simulation-steps', 'file-generation'];
-        this.init();
-        this.initializeTooltips();
-    }
-
-    init() {
-        this.setupEventListeners();
-        this.initializeTabs();
-        this.initializeStepToggles();
-        this.loadDefaultParams();
-        this.updateNavigationState();
-    }
-
-    initializeTooltips() {
-        // Initialize Bootstrap tooltips using vanilla JavaScript
-        // Note: This requires Bootstrap to be loaded
-        if (typeof bootstrap !== 'undefined' && bootstrap.Tooltip) {
-            const tooltipTriggerList = [].slice.call(document.querySelectorAll('[data-toggle="tooltip"]'));
-            tooltipTriggerList.map(function (tooltipTriggerEl) {
-                return new bootstrap.Tooltip(tooltipTriggerEl);
-            });
-        } else {
-            console.log('Bootstrap not loaded, tooltips will not work');
-        }
-    }
-
-    setupEventListeners() {
-        // Tab navigation
-        document.querySelectorAll('.tab-button').forEach(button => {
-            button.addEventListener('click', (e) => this.switchTab(e.target.dataset.tab));
-        });
-
-        // File upload
-        const fileInput = document.getElementById('pdb-file');
-        const fileUploadArea = document.getElementById('file-upload-area');
-        const chooseFileBtn = document.getElementById('choose-file-btn');
-        
-        console.log('File input element:', fileInput);
-        console.log('File upload area:', fileUploadArea);
-        console.log('Choose file button:', chooseFileBtn);
-        
-        if (!fileInput) {
-            console.error('File input element not found!');
-            return;
-        }
-        
-        fileInput.addEventListener('change', (e) => this.handleFileUpload(e));
-        
-        // Handle click on upload area (but not on the button)
-        fileUploadArea.addEventListener('click', (e) => {
-            // Only trigger if not clicking on the button
-            if (e.target !== chooseFileBtn && !chooseFileBtn.contains(e.target)) {
-                console.log('Upload area clicked, triggering file input');
-                fileInput.click();
-            }
-        });
-        
-        // Handle click on choose file button
-        chooseFileBtn.addEventListener('click', (e) => {
-            e.stopPropagation(); // Prevent triggering the upload area click
-            console.log('Choose file button clicked, triggering file input');
-            fileInput.click();
-        });
-        
-        fileUploadArea.addEventListener('dragover', (e) => this.handleDragOver(e));
-        fileUploadArea.addEventListener('drop', (e) => this.handleDrop(e));
-
-        // PDB fetch
-        document.getElementById('fetch-pdb').addEventListener('click', () => this.fetchPDB());
-
-        // File generation
-        document.getElementById('generate-files').addEventListener('click', () => this.generateAllFiles());
-        document.getElementById('preview-files').addEventListener('click', () => this.previewFiles());
-        document.getElementById('preview-solvated').addEventListener('click', () => this.previewSolvatedProtein());
-        document.getElementById('download-zip').addEventListener('click', () => this.downloadZip());
-        
-
-        // Structure preparation
-        document.getElementById('prepare-structure').addEventListener('click', () => this.prepareStructure());
-        document.getElementById('preview-prepared').addEventListener('click', () => this.previewPreparedStructure());
-        document.getElementById('download-prepared').addEventListener('click', () => this.downloadPreparedStructure());
-        
-        // Ligand download button
-        const downloadLigandBtn = document.getElementById('download-ligand');
-        if (downloadLigandBtn) {
-            downloadLigandBtn.addEventListener('click', (e) => {
-                e.preventDefault();
-                this.downloadLigandFile();
-            });
-        }
-
-        // Navigation buttons
-        document.getElementById('prev-tab').addEventListener('click', () => this.previousTab());
-        document.getElementById('next-tab').addEventListener('click', () => this.nextTab());
-
-        // Parameter changes
-        document.querySelectorAll('input, select').forEach(input => {
-            input.addEventListener('change', () => this.updateSimulationParams());
-        });
-
-        // Render chain and ligand choices when structure tab becomes visible
-        document.querySelector('[data-tab="structure-prep"]').addEventListener('click', () => {
-            this.renderChainAndLigandSelections();
-        });
-
-        // Separate ligands checkbox change
-        document.getElementById('separate-ligands').addEventListener('change', (e) => {
-            const downloadBtn = document.getElementById('download-ligand');
-            
-            if (e.target.checked && this.preparedProtein && this.preparedProtein.ligand_present && this.preparedProtein.ligand_content) {
-                downloadBtn.disabled = false;
-                downloadBtn.classList.remove('btn-outline-secondary');
-                downloadBtn.classList.add('btn-outline-primary');
-            } else {
-                downloadBtn.disabled = true;
-                downloadBtn.classList.remove('btn-outline-primary');
-                downloadBtn.classList.add('btn-outline-secondary');
-            }
-        });
-
-        // Preserve ligands checkbox change
-        document.getElementById('preserve-ligands').addEventListener('change', (e) => {
-            this.toggleLigandForceFieldGroup(e.target.checked);
-        });
-    }
-
-    initializeTabs() {
-        const tabs = document.querySelectorAll('.tab-content');
-        tabs.forEach(tab => {
-            if (!tab.classList.contains('active')) {
-                tab.style.display = 'none';
-            }
-        });
-    }
-
-    initializeStepToggles() {
-        document.querySelectorAll('.step-header').forEach(header => {
-            header.addEventListener('click', () => {
-                const stepItem = header.parentElement;
-                const content = stepItem.querySelector('.step-content');
-                const isActive = content.classList.contains('active');
-                
-                // Close all other step contents
-                document.querySelectorAll('.step-content').forEach(c => c.classList.remove('active'));
-                
-                // Toggle current step
-                if (!isActive) {
-                    content.classList.add('active');
-                }
-            });
-        });
-    }
-
-    loadDefaultParams() {
-        this.simulationParams = {
-            boxType: 'cubic',
-            boxSize: 1.0,
-            boxMargin: 1.0,
-            forceField: 'amber99sb-ildn',
-            waterModel: 'tip3p',
-            ionConcentration: 150,
-            temperature: 300,
-            pressure: 1.0,
-            couplingType: 'berendsen',
-            timestep: 0.002,
-            cutoff: 1.0,
-            pmeOrder: 4,
-            steps: {
-                restrainedMin: { enabled: true, steps: 1000, force: 1000 },
-                minimization: { enabled: true, steps: 5000, algorithm: 'steep' },
-                nvt: { enabled: true, steps: 50000, temperature: 300 },
-                npt: { enabled: true, steps: 100000, temperature: 300, pressure: 1.0 },
-                production: { enabled: true, steps: 1000000, temperature: 300, pressure: 1.0 }
-            }
-        };
-    }
-
-    switchTab(tabName) {
-        // Hide all tab contents
-        document.querySelectorAll('.tab-content').forEach(tab => {
-            tab.classList.remove('active');
-            tab.style.display = 'none';
-        });
-
-        // Remove active class from all tab buttons
-        document.querySelectorAll('.tab-button').forEach(button => {
-            button.classList.remove('active');
-        });
-
-        // Show selected tab
-        document.getElementById(tabName).classList.add('active');
-        document.getElementById(tabName).style.display = 'block';
-        
-        // Add active class to clicked button
-        document.querySelector(`[data-tab="${tabName}"]`).classList.add('active');
-
-        // Update current tab index and navigation state
-        this.currentTabIndex = this.tabOrder.indexOf(tabName);
-        this.updateNavigationState();
-    }
-
-    previousTab() {
-        if (this.currentTabIndex > 0) {
-            const prevTab = this.tabOrder[this.currentTabIndex - 1];
-            this.switchTab(prevTab);
-        }
-    }
-
-    nextTab() {
-        if (this.currentTabIndex < this.tabOrder.length - 1) {
-            const nextTab = this.tabOrder[this.currentTabIndex + 1];
-            this.switchTab(nextTab);
-        }
-    }
-
-    updateNavigationState() {
-        const prevBtn = document.getElementById('prev-tab');
-        const nextBtn = document.getElementById('next-tab');
-        const currentStepSpan = document.getElementById('current-step');
-        const totalStepsSpan = document.getElementById('total-steps');
-
-        // Update button states
-        prevBtn.disabled = this.currentTabIndex === 0;
-        nextBtn.disabled = this.currentTabIndex === this.tabOrder.length - 1;
-
-        // Update step indicator
-        if (currentStepSpan) {
-            currentStepSpan.textContent = this.currentTabIndex + 1;
-        }
-        if (totalStepsSpan) {
-            totalStepsSpan.textContent = this.tabOrder.length;
-        }
-
-        // Update next button text based on current tab
-        if (this.currentTabIndex === this.tabOrder.length - 1) {
-            nextBtn.innerHTML = 'Complete <i class="fas fa-check"></i>';
-        } else {
-            nextBtn.innerHTML = 'Next <i class="fas fa-chevron-right"></i>';
-        }
-    }
-
-    handleDragOver(e) {
-        e.preventDefault();
-        e.currentTarget.style.background = '#e3f2fd';
-    }
-
-    handleDrop(e) {
-        e.preventDefault();
-        e.currentTarget.style.background = '#f8f9fa';
-        
-        const files = e.dataTransfer.files;
-        if (files.length > 0) {
-            this.processFile(files[0]);
-        }
-    }
-
-    handleFileUpload(e) {
-        console.log('File upload triggered');
-        console.log('Files:', e.target.files);
-        const file = e.target.files[0];
-        if (file) {
-            console.log('File selected:', file.name, file.size, file.type);
-            this.processFile(file);
-        } else {
-            console.log('No file selected');
-        }
-    }
-
-    processFile(file) {
-        console.log('Processing file:', file.name, file.size, file.type);
-        
-        if (!file.name.toLowerCase().endsWith('.pdb') && !file.name.toLowerCase().endsWith('.ent')) {
-            console.log('Invalid file type:', file.name);
-            this.showStatus('error', 'Please upload a valid PDB file (.pdb or .ent)');
-            return;
-        }
-
-        console.log('File validation passed, reading file...');
-        const reader = new FileReader();
-        reader.onload = (e) => {
-            console.log('File read successfully, content length:', e.target.result.length);
-            const content = e.target.result;
-            this.parsePDBFile(content, file.name);
-        };
-        reader.onerror = (e) => {
-            console.error('Error reading file:', e);
-            this.showStatus('error', 'Error reading file');
-        };
-        reader.readAsText(file);
-    }
-
-    async parsePDBFile(content, filename) {
-        try {
-            // Clean output folder when new PDB is loaded
-            try {
-                await fetch('/api/clean-output', { method: 'POST' });
-            } catch (error) {
-                console.log('Could not clean output folder:', error);
-            }
-            
-            const lines = content.split('\n');
-            let atomCount = 0;
-            let chains = new Set();
-            let residues = new Set();
-            let waterMolecules = 0;
-            let ions = 0;
-            let ligands = new Set();
-            let ligandDetails = [];
-            let ligandGroups = new Map(); // Group by RESN-CHAIN
-            let hetatoms = 0;
-            let structureId = filename.replace(/\.(pdb|ent)$/i, '').toUpperCase();
-            
-            // Common water molecule names
-            const waterNames = new Set(['HOH', 'WAT', 'TIP3', 'TIP4', 'SPC', 'SPCE']);
-            
-            // Common ion names (expanded to include more ions)
-            const ionNames = new Set(['NA', 'CL', 'K', 'MG', 'CA', 'ZN', 'FE', 'MN', 'CU', 'NI', 'CO', 
-                'CD', 'HG', 'PB', 'SR', 'BA', 'RB', 'CS', 'LI', 'F', 'BR', 'I', 'SO4', 'PO4', 'CO3', 'NO3', 'NH4']);
-            
-            // Track ligand entities (separated by TER or different chains)
-            let ligandEntities = new Map(); // Map to store ligand entities
-            let currentLigandEntity = null;
-            let currentChain = null;
-            let currentResidue = null;
-            
-            // Track unique water molecules by residue
-            const uniqueWaterResidues = new Set();
-
-            lines.forEach(line => {
-                if (line.startsWith('ATOM')) {
-                    atomCount++;
-                    const chainId = line.substring(21, 22).trim();
-                    if (chainId) chains.add(chainId);
-                    
-                    const resName = line.substring(17, 20).trim();
-                    const resNum = line.substring(22, 26).trim();
-                    residues.add(`${resName}${resNum}`);
-                } else if (line.startsWith('HETATM')) {
-                    hetatoms++;
-                    const resName = line.substring(17, 20).trim();
-                    const resNum = line.substring(22, 26).trim();
-                    const chainId = line.substring(21, 22).trim();
-                    const entityKey = `${resName}_${resNum}_${chainId}`;
-                    
-                    if (waterNames.has(resName)) {
-                        waterMolecules++;
-                        uniqueWaterResidues.add(entityKey);
-                    } else if (ionNames.has(resName)) {
-                        ions++;
-                    } else {
-                        // Everything else is treated as ligand (FALLBACK LOGIC)
-                        ligands.add(resName);
-                        ligandDetails.push({ resn: resName, chain: chainId, resi: resNum });
-                        
-                        // Group by RESN-CHAIN for UI display
-                        const groupKey = `${resName}-${chainId}`;
-                        if (!ligandGroups.has(groupKey)) {
-                            ligandGroups.set(groupKey, { resn: resName, chain: chainId });
-                        }
-                        
-                        // Track ligand entities (separated by TER or different chains)
-                        if (currentChain !== chainId || currentResidue !== resName) {
-                            // New ligand entity detected
-                            currentLigandEntity = `${resName}_${chainId}`;
-                            currentChain = chainId;
-                            currentResidue = resName;
-                            
-                            if (!ligandEntities.has(currentLigandEntity)) {
-                                ligandEntities.set(currentLigandEntity, {
-                                    name: resName,
-                                    chain: chainId,
-                                    residueNum: resNum,
-                                    atomCount: 0
-                                });
-                            }
-                        }
-                        
-                        // Increment atom count for this ligand entity
-                        if (ligandEntities.has(currentLigandEntity)) {
-                            ligandEntities.get(currentLigandEntity).atomCount++;
-                        }
-                    }
-                } else if (line.startsWith('TER')) {
-                    // TER record separates entities, reset current ligand tracking
-                    currentLigandEntity = null;
-                    currentChain = null;
-                    currentResidue = null;
-                }
-            });
-
-            // Count unique water molecules
-            const uniqueWaterCount = uniqueWaterResidues.size;
-            
-            // Count ligand entities (different ligands or same ligand in different chains)
-            const ligandEntityCount = ligandEntities.size;
-            
-            // Get unique ligand names
-            const uniqueLigandNames = Array.from(ligands);
-            
-            // Create ligand info string
-            let ligandInfo = 'None';
-            if (uniqueLigandNames.length > 0) {
-                if (ligandEntityCount > 1) {
-                    // Multiple entities - show count and names
-                    ligandInfo = `${ligandEntityCount} entities: ${uniqueLigandNames.join(', ')}`;
-                } else {
-                    // Single entity
-                    ligandInfo = uniqueLigandNames.join(', ');
-                }
-            }
-
-            this.currentProtein = {
-                filename: filename,
-                structureId: structureId,
-                atomCount: atomCount,
-                chains: Array.from(chains),
-                residueCount: residues.size,
-                waterMolecules: uniqueWaterCount,
-                ions: ions,
-                ligands: uniqueLigandNames,
-                ligandDetails: ligandDetails,
-                ligandGroups: Array.from(ligandGroups.values()), // RESN-CHAIN groups for UI
-                ligandEntities: ligandEntityCount,
-                ligandInfo: ligandInfo,
-                hetatoms: hetatoms,
-                content: content
-            };
-
-            this.displayProteinInfo();
-            this.showStatus('success', `Successfully loaded ${filename}`);
-        } catch (error) {
-            this.showStatus('error', 'Error parsing PDB file: ' + error.message);
-        }
-    }
-
-    displayProteinInfo() {
-        if (!this.currentProtein) return;
-
-        document.getElementById('structure-id').textContent = this.currentProtein.structureId;
-        document.getElementById('atom-count').textContent = this.currentProtein.atomCount.toLocaleString();
-        document.getElementById('chain-info').textContent = this.currentProtein.chains.join(', ');
-        document.getElementById('residue-count').textContent = this.currentProtein.residueCount.toLocaleString();
-        document.getElementById('water-count').textContent = this.currentProtein.waterMolecules.toLocaleString();
-        document.getElementById('ion-count').textContent = this.currentProtein.ions.toLocaleString();
-        document.getElementById('ligand-info').textContent = this.currentProtein.ligandInfo;
-        document.getElementById('hetatm-count').textContent = this.currentProtein.hetatoms.toLocaleString();
-
-        document.getElementById('protein-preview').style.display = 'block';
-        
-        // Load 3D visualization
-        this.load3DVisualization();
-
-        // Also refresh chain/ligand lists when protein info is displayed
-        this.renderChainAndLigandSelections();
-    }
-
-    async fetchPDB() {
-        const pdbId = document.getElementById('pdb-id').value.trim().toUpperCase();
-        if (!pdbId) {
-            this.showStatus('error', 'Please enter a PDB ID');
-            return;
-        }
-
-        if (!/^[0-9A-Z]{4}$/.test(pdbId)) {
-            this.showStatus('error', 'Please enter a valid 4-character PDB ID');
-            return;
-        }
-
-        this.showStatus('info', 'Fetching PDB structure...');
-        
-        try {
-            const response = await fetch(`https://files.rcsb.org/download/${pdbId}.pdb`);
-            if (!response.ok) {
-                throw new Error(`PDB ID ${pdbId} not found`);
-            }
-            
-            const content = await response.text();
-            this.parsePDBFile(content, `${pdbId}.pdb`);
-            this.showStatus('success', `Successfully fetched PDB structure ${pdbId}`);
-        } catch (error) {
-            this.showStatus('error', `Error fetching PDB: ${error.message}`);
-        }
-    }
-
-    showStatus(type, message) {
-        const statusDiv = document.getElementById('pdb-status');
-        statusDiv.className = `status-message ${type}`;
-        statusDiv.textContent = message;
-        statusDiv.style.display = 'block';
-
-        // Auto-hide after 5 seconds for success messages
-        if (type === 'success') {
-            setTimeout(() => {
-                statusDiv.style.display = 'none';
-            }, 5000);
-        }
-    }
-
-    updateSimulationParams() {
-        // Update basic parameters
-        this.simulationParams.boxType = document.getElementById('box-type').value;
-        this.simulationParams.boxSize = parseFloat(document.getElementById('box-size').value);
-        this.simulationParams.forceField = document.getElementById('force-field').value;
-        this.simulationParams.waterModel = document.getElementById('water-model').value;
-        this.simulationParams.addIons = document.getElementById('add-ions').value;
-        this.simulationParams.temperature = parseInt(document.getElementById('temperature').value);
-        this.simulationParams.pressure = parseFloat(document.getElementById('pressure').value);
-        this.simulationParams.couplingType = document.getElementById('coupling-type').value;
-        this.simulationParams.timestep = parseFloat(document.getElementById('timestep').value);
-        this.simulationParams.cutoff = parseFloat(document.getElementById('cutoff').value);
-        this.simulationParams.electrostatic = document.getElementById('electrostatic').value;
-        this.simulationParams.ligandForceField = document.getElementById('ligand-forcefield').value;
-
-        // Update step parameters
-        this.simulationParams.steps.restrainedMin = {
-            enabled: document.getElementById('enable-restrained-min').checked,
-            steps: parseInt(document.getElementById('restrained-steps').value),
-            force: parseInt(document.getElementById('restrained-force').value)
-        };
-
-        this.simulationParams.steps.minimization = {
-            enabled: document.getElementById('enable-minimization').checked,
-            steps: parseInt(document.getElementById('min-steps').value),
-            algorithm: document.getElementById('min-algorithm').value
-        };
-
-        this.simulationParams.steps.nvt = {
-            enabled: document.getElementById('enable-nvt').checked,
-            steps: parseInt(document.getElementById('nvt-steps').value),
-            temperature: parseInt(document.getElementById('nvt-temp').value)
-        };
-
-        this.simulationParams.steps.npt = {
-            enabled: document.getElementById('enable-npt').checked,
-            steps: parseInt(document.getElementById('npt-steps').value),
-            temperature: parseInt(document.getElementById('npt-temp').value),
-            pressure: parseFloat(document.getElementById('npt-pressure').value)
-        };
-
-        this.simulationParams.steps.production = {
-            enabled: document.getElementById('enable-production').checked,
-            steps: parseInt(document.getElementById('prod-steps').value),
-            temperature: parseInt(document.getElementById('prod-temp').value),
-            pressure: parseFloat(document.getElementById('prod-pressure').value)
-        };
-    }
-
-    toggleLigandForceFieldGroup(show) {
-        const section = document.getElementById('ligand-forcefield-section');
-        if (show) {
-            section.style.display = 'block';
-            section.classList.remove('disabled');
-        } else {
-            section.style.display = 'none';
-            section.classList.add('disabled');
-        }
-    }
-
-    async calculateNetCharge(event) {
-        console.log('calculateNetCharge called'); // Debug log
-        if (!this.preparedProtein) {
-            alert('Please prepare structure first before calculating net charge.');
-            return;
-        }
-
-        // Show loading state
-        const button = event ? event.target : document.querySelector('button[onclick*="calculateNetCharge"]');
-        const originalText = button.innerHTML;
-        button.innerHTML = '<i class="fas fa-spinner fa-spin"></i> Calculating...';
-        button.disabled = true;
-
-        try {
-            // Get the selected force field
-            const selectedForceField = document.getElementById('force-field').value;
-            
-            const response = await fetch('/api/calculate-net-charge', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    force_field: selectedForceField
-                })
-            });
-
-            const result = await response.json();
-
-            if (result.success) {
-                // Update the Add Ions dropdown based on suggestion
-                const addIonsSelect = document.getElementById('add-ions');
-                if (result.ion_type === 'Cl-') {
-                    addIonsSelect.value = 'Cl-';
-                } else if (result.ion_type === 'Na+') {
-                    addIonsSelect.value = 'Na+';
-                } else {
-                    addIonsSelect.value = 'None';
-                }
-
-                // Show detailed results
-                alert(`✅ System Charge Analysis Complete!\n\n` +
-                      `Net Charge: ${result.net_charge}\n` +
-                      `Recommendation: ${result.suggestion}\n` +
-                      `Ligand Present: ${result.ligand_present ? 'Yes' : 'No'}`);
-            } else {
-                alert(`❌ Error: ${result.error}`);
-            }
-        } catch (error) {
-            console.error('Error calculating net charge:', error);
-            alert(`❌ Error: Failed to calculate net charge. ${error.message}`);
-        } finally {
-            // Restore button state
-            button.innerHTML = originalText;
-            button.disabled = false;
-        }
-    }
-
-    async generateLigandFF(event) {
-        console.log('generateLigandFF called'); // Debug log
-        if (!this.preparedProtein || !this.preparedProtein.ligand_present) {
-            alert('No ligand found. Please ensure ligands are preserved during structure preparation.');
-            return;
-        }
-
-        const selectedFF = document.getElementById('ligand-forcefield').value;
-        
-        // Show loading state
-        const button = event ? event.target : document.querySelector('button[onclick*="generateLigandFF"]');
-        const originalText = button.innerHTML;
-        button.innerHTML = '<i class="fas fa-spinner fa-spin"></i> Generating...';
-        button.disabled = true;
-
-        try {
-            const response = await fetch('/api/generate-ligand-ff', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    force_field: selectedFF
-                })
-            });
-
-            const result = await response.json();
-
-            if (result.success) {
-                alert(`✅ ${result.message}\n\nNet charge: ${result.net_charge}\n\nGenerated files:\n- ${result.files.mol2}\n- ${result.files.frcmod}`);
-            } else {
-                alert(`❌ Error: ${result.error}`);
-            }
-        } catch (error) {
-            console.error('Error generating ligand force field:', error);
-            alert(`❌ Error: Failed to generate force field parameters. ${error.message}`);
-        } finally {
-            // Restore button state
-            button.innerHTML = originalText;
-            button.disabled = false;
-        }
-    }
-
-    countAtomsInPDB(pdbContent) {
-        const lines = pdbContent.split('\n');
-        return lines.filter(line => line.startsWith('ATOM') || line.startsWith('HETATM')).length;
-    }
-
-    async generateAllFiles() {
-        if (!this.preparedProtein) {
-            alert('Please prepare structure first');
-            return;
-        }
-
-        // Show loading state
-        const button = document.getElementById('generate-files');
-        const originalText = button.innerHTML;
-        button.innerHTML = '<i class="fas fa-spinner fa-spin"></i> Generating...';
-        button.disabled = true;
-
-        try {
-               // Collect all simulation parameters
-               const params = {
-                   cutoff_distance: parseFloat(document.getElementById('cutoff').value),
-                   temperature: parseFloat(document.getElementById('temperature').value),
-                   pressure: parseFloat(document.getElementById('pressure').value),
-                   restrained_steps: parseInt(document.getElementById('restrained-steps').value),
-                   restrained_force: parseFloat(document.getElementById('restrained-force').value),
-                   min_steps: parseInt(document.getElementById('min-steps').value),
-                   npt_heating_steps: parseInt(document.getElementById('nvt-steps').value),
-                   npt_equilibration_steps: parseInt(document.getElementById('npt-steps').value),
-                   production_steps: parseInt(document.getElementById('prod-steps').value),
-                   timestep: parseFloat(document.getElementById('timestep').value),
-                   // Force field parameters
-                   force_field: document.getElementById('force-field').value,
-                   water_model: document.getElementById('water-model').value,
-                   add_ions: document.getElementById('add-ions').value,
-                   distance: parseFloat(document.getElementById('box-size').value)
-               };
-
-            const response = await fetch('/api/generate-all-files', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(params)
-            });
-
-            const result = await response.json();
-
-            if (result.success) {
-                let message = `✅ ${result.message}\n\nGenerated files:\n`;
-                result.files_generated.forEach(file => {
-                    message += `- ${file}\n`;
-                });
-                
-                if (result.warnings && result.warnings.length > 0) {
-                    message += `\n⚠️ Warnings:\n`;
-                    result.warnings.forEach(warning => {
-                        message += `- ${warning}\n`;
-                    });
-                }
-                
-                alert(message);
-
-                // Reveal the download section
-                const downloadSection = document.getElementById('download-section');
-                if (downloadSection) {
-                    downloadSection.style.display = 'block';
-                }
-            } else {
-                alert(`❌ Error: ${result.error}`);
-            }
-        } catch (error) {
-            console.error('Error generating files:', error);
-            alert(`❌ Error: Failed to generate simulation files. ${error.message}`);
-        } finally {
-            // Restore button state
-            button.innerHTML = originalText;
-            button.disabled = false;
-        }
-    }
-
-    createSimulationFiles() {
-        const files = {};
-        const proteinName = this.currentProtein.structureId.toLowerCase();
-        
-        // Generate GROMACS input files
-        files[`${proteinName}.mdp`] = this.generateMDPFile();
-        files[`${proteinName}_restrained.mdp`] = this.generateRestrainedMDPFile();
-        files[`${proteinName}_min.mdp`] = this.generateMinimizationMDPFile();
-        files[`${proteinName}_nvt.mdp`] = this.generateNVTMDPFile();
-        files[`${proteinName}_npt.mdp`] = this.generateNPTMDPFile();
-        files[`${proteinName}_prod.mdp`] = this.generateProductionMDPFile();
-        
-        // Generate PBS script
-        files[`${proteinName}_simulation.pbs`] = this.generatePBSScript();
-        
-        // Generate setup script
-        files[`setup_${proteinName}.sh`] = this.generateSetupScript();
-        
-        // Generate analysis script
-        files[`analyze_${proteinName}.sh`] = this.generateAnalysisScript();
-
-        return files;
-    }
-
-    generateMDPFile() {
-        const params = this.simulationParams;
-        return `; MD Simulation Parameters
-; Generated by MD Simulation Pipeline
-
-; Run parameters
-integrator = md
-dt = ${params.timestep}
-nsteps = ${params.steps.production.steps}
-
-; Output control
-nstxout = 5000
-nstvout = 5000
-nstenergy = 1000
-nstlog = 1000
-
-; Bond parameters
-constraint_algorithm = lincs
-constraints = h-bonds
-lincs_iter = 1
-lincs_order = 4
-
-; Neighbor searching
-cutoff-scheme = Verlet
-ns_type = grid
-nstlist = 40
-rlist = ${params.cutoff}
-
-; Electrostatics
-coulombtype = PME
-rcoulomb = ${params.cutoff}
-pme_order = ${params.pmeOrder}
-fourierspacing = 0.16
-
-; Van der Waals
-vdwtype = Cut-off
-rvdw = ${params.cutoff}
-
-; Temperature coupling
-tcoupl = ${params.couplingType}
-tc-grps = Protein Non-Protein
-tau_t = 0.1 0.1
-ref_t = ${params.temperature} ${params.temperature}
-
-; Pressure coupling
-pcoupl = ${params.couplingType}
-pcoupltype = isotropic
-tau_p = 2.0
-ref_p = ${params.pressure}
-compressibility = 4.5e-5
-
-; Dispersion correction
-DispCorr = EnerPres
-
-; Velocity generation
-gen_vel = yes
-gen_temp = ${params.temperature}
-gen_seed = -1
-`;
-    }
-
-    generateRestrainedMDPFile() {
-        const params = this.simulationParams;
-        return `; Restrained Minimization Parameters
-integrator = steep
-nsteps = ${params.steps.restrainedMin.steps}
-emstep = 0.01
-emtol = 1000
-
-; Position restraints
-define = -DPOSRES
-refcoord_scaling = com
-
-; Output control
-nstxout = 100
-nstenergy = 100
-nstlog = 100
-
-; Bond parameters
-constraint_algorithm = lincs
-constraints = h-bonds
-
-; Neighbor searching
-cutoff-scheme = Verlet
-ns_type = grid
-nstlist = 10
-rlist = ${params.cutoff}
-
-; Electrostatics
-coulombtype = PME
-rcoulomb = ${params.cutoff}
-pme_order = ${params.pme_order}
-
-; Van der Waals
-vdwtype = Cut-off
-rvdw = ${params.cutoff}
-`;
-    }
-
-    generateMinimizationMDPFile() {
-        const params = this.simulationParams;
-        return `; Minimization Parameters
-integrator = ${params.steps.minimization.algorithm}
-nsteps = ${params.steps.minimization.steps}
-emstep = 0.01
-emtol = 1000
-
-; Output control
-nstxout = 100
-nstenergy = 100
-nstlog = 100
-
-; Bond parameters
-constraint_algorithm = lincs
-constraints = h-bonds
-
-; Neighbor searching
-cutoff-scheme = Verlet
-ns_type = grid
-nstlist = 10
-rlist = ${params.cutoff}
-
-; Electrostatics
-coulombtype = PME
-rcoulomb = ${params.cutoff}
-pme_order = ${params.pme_order}
-
-; Van der Waals
-vdwtype = Cut-off
-rvdw = ${params.cutoff}
-`;
-    }
-
-    generateNVTMDPFile() {
-        const params = this.simulationParams;
-        return `; NVT Equilibration Parameters
-integrator = md
-dt = ${params.timestep}
-nsteps = ${params.steps.nvt.steps}
-
-; Output control
-nstxout = 5000
-nstvout = 5000
-nstenergy = 1000
-nstlog = 1000
-
-; Bond parameters
-constraint_algorithm = lincs
-constraints = h-bonds
-lincs_iter = 1
-lincs_order = 4
-
-; Neighbor searching
-cutoff-scheme = Verlet
-ns_type = grid
-nstlist = 40
-rlist = ${params.cutoff}
-
-; Electrostatics
-coulombtype = PME
-rcoulomb = ${params.cutoff}
-pme_order = ${params.pme_order}
-
-; Van der Waals
-vdwtype = Cut-off
-rvdw = ${params.cutoff}
-
-; Temperature coupling
-tcoupl = ${params.couplingType}
-tc-grps = Protein Non-Protein
-tau_t = 0.1 0.1
-ref_t = ${params.steps.nvt.temperature} ${params.steps.nvt.temperature}
-
-; Pressure coupling (disabled for NVT)
-pcoupl = no
-
-; Velocity generation
-gen_vel = yes
-gen_temp = ${params.steps.nvt.temperature}
-gen_seed = -1
-`;
-    }
-
-    generateNPTMDPFile() {
-        const params = this.simulationParams;
-        return `; NPT Equilibration Parameters
-integrator = md
-dt = ${params.timestep}
-nsteps = ${params.steps.npt.steps}
-
-; Output control
-nstxout = 5000
-nstvout = 5000
-nstenergy = 1000
-nstlog = 1000
-
-; Bond parameters
-constraint_algorithm = lincs
-constraints = h-bonds
-lincs_iter = 1
-lincs_order = 4
-
-; Neighbor searching
-cutoff-scheme = Verlet
-ns_type = grid
-nstlist = 40
-rlist = ${params.cutoff}
-
-; Electrostatics
-coulombtype = PME
-rcoulomb = ${params.cutoff}
-pme_order = ${params.pme_order}
-
-; Van der Waals
-vdwtype = Cut-off
-rvdw = ${params.cutoff}
-
-; Temperature coupling
-tcoupl = ${params.couplingType}
-tc-grps = Protein Non-Protein
-tau_t = 0.1 0.1
-ref_t = ${params.steps.npt.temperature} ${params.steps.npt.temperature}
-
-; Pressure coupling
-pcoupl = ${params.couplingType}
-pcoupltype = isotropic
-tau_p = 2.0
-ref_p = ${params.steps.npt.pressure}
-compressibility = 4.5e-5
-
-; Velocity generation
-gen_vel = no
-`;
-    }
-
-    generateProductionMDPFile() {
-        return this.generateMDPFile(); // Same as main MDP file
-    }
-
-    generatePBSScript() {
-        const proteinName = this.currentProtein.structureId.toLowerCase();
-        const totalSteps = this.simulationParams.steps.production.steps;
-        const timeInNs = (totalSteps * this.simulationParams.timestep) / 1000;
-        
-        return `#!/bin/bash
-#PBS -N ${proteinName}_md
-#PBS -l nodes=1:ppn=16
-#PBS -l walltime=24:00:00
-#PBS -q normal
-#PBS -j oe
-
-# Change to the directory where the job was submitted
-cd $PBS_O_WORKDIR
-
-# Load required modules
-module load gromacs/2023.2
-module load intel/2021.4.0
-
-# Set up environment
-export OMP_NUM_THREADS=16
-export GMX_MAXBACKUP=-1
-
-# Simulation parameters
-PROTEIN=${proteinName}
-STEPS=${totalSteps}
-TIME_NS=${timeInNs.toFixed(2)}
-
-echo "Starting MD simulation for $PROTEIN"
-echo "Total simulation time: $TIME_NS ns"
-echo "Job started at: $(date)"
-
-# Run the simulation
-./run_simulation.sh $PROTEIN
-
-echo "Simulation completed at: $(date)"
-echo "Results saved in output directory"
-`;
-    }
-
-    generateSetupScript() {
-        const proteinName = this.currentProtein.structureId.toLowerCase();
-        return `#!/bin/bash
-# Setup script for ${proteinName} MD simulation
-# Generated by MD Simulation Pipeline
-
-set -e
-
-PROTEIN=${proteinName}
-FORCE_FIELD=${this.simulationParams.forceField}
-WATER_MODEL=${this.simulationParams.waterModel}
-
-echo "Setting up MD simulation for $PROTEIN"
-
-# Create output directory
-mkdir -p output
-
-# 1. Prepare protein structure
-echo "Preparing protein structure..."
-gmx pdb2gmx -f ${PROTEIN}.pdb -o ${PROTEIN}_processed.gro -p ${PROTEIN}.top -ff ${FORCE_FIELD} -water ${WATER_MODEL}
-
-# 2. Define simulation box
-echo "Defining simulation box..."
-gmx editconf -f ${PROTEIN}_processed.gro -o ${PROTEIN}_box.gro -c -d ${this.simulationParams.boxMargin} -bt ${this.simulationParams.boxType}
-
-# 3. Add solvent
-echo "Adding solvent..."
-gmx solvate -cp ${PROTEIN}_box.gro -cs spc216.gro -o ${PROTEIN}_solv.gro -p ${PROTEIN}.top
-
-# 4. Add ions
-echo "Adding ions..."
-gmx grompp -f ${PROTEIN}_restrained.mdp -c ${PROTEIN}_solv.gro -p ${PROTEIN}.top -o ${PROTEIN}_ions.tpr
-echo "SOL" | gmx genion -s ${PROTEIN}_ions.tpr -o ${PROTEIN}_final.gro -p ${PROTEIN}.top -pname NA -nname CL -neutral
-
-echo "Setup completed successfully!"
-echo "Ready to run simulation with: ./run_simulation.sh $PROTEIN"
-`;
-    }
-
-    generateAnalysisScript() {
-        const proteinName = this.currentProtein.structureId.toLowerCase();
-        return `#!/bin/bash
-# Analysis script for ${proteinName} MD simulation
-# Generated by MD Simulation Pipeline
-
-PROTEIN=${proteinName}
-
-echo "Analyzing MD simulation results for $PROTEIN"
-
-# Create analysis directory
-mkdir -p analysis
-
-# 1. RMSD analysis
-echo "Calculating RMSD..."
-echo "Protein" | gmx rms -s ${PROTEIN}_final.tpr -f ${PROTEIN}_prod.xtc -o analysis/${PROTEIN}_rmsd.xvg -tu ns
-
-# 2. RMSF analysis
-echo "Calculating RMSF..."
-echo "Protein" | gmx rmsf -s ${PROTEIN}_final.tpr -f ${PROTEIN}_prod.xtc -o analysis/${PROTEIN}_rmsf.xvg -res
-
-# 3. Radius of gyration
-echo "Calculating radius of gyration..."
-echo "Protein" | gmx gyrate -s ${PROTEIN}_final.tpr -f ${PROTEIN}_prod.xtc -o analysis/${PROTEIN}_gyrate.xvg
-
-# 4. Hydrogen bonds
-echo "Analyzing hydrogen bonds..."
-echo "Protein" | gmx hbond -s ${PROTEIN}_final.tpr -f ${PROTEIN}_prod.xtc -num analysis/${PROTEIN}_hbonds.xvg
-
-# 5. Energy analysis
-echo "Analyzing energies..."
-gmx energy -f ${PROTEIN}_prod.edr -o analysis/${PROTEIN}_energy.xvg
-
-# 6. Generate plots
-echo "Generating analysis plots..."
-python3 plot_analysis.py ${PROTEIN}
-
-echo "Analysis completed! Results saved in analysis/ directory"
-`;
-    }
-
-    displayGeneratedFiles() {
-        const filesList = document.getElementById('files-list');
-        filesList.innerHTML = '';
-
-        Object.entries(this.generatedFiles).forEach(([filename, content]) => {
-            const fileItem = document.createElement('div');
-            fileItem.className = 'file-item';
-            
-            const fileType = this.getFileType(filename);
-            const fileSize = this.formatFileSize(content.length);
-            
-            fileItem.innerHTML = `
-                <h4><i class="fas ${this.getFileIcon(filename)}"></i> ${filename}</h4>
-                <p><strong>Type:</strong> ${fileType}</p>
-                <p><strong>Size:</strong> ${fileSize}</p>
-                <button class="btn btn-secondary btn-sm" onclick="mdPipeline.previewFile('${filename}')">
-                    <i class="fas fa-eye"></i> Preview
-                </button>
-                <button class="btn btn-primary btn-sm" onclick="mdPipeline.downloadFile('${filename}')">
-                    <i class="fas fa-download"></i> Download
-                </button>
-            `;
-            
-            filesList.appendChild(fileItem);
-        });
-    }
-
-    getFileType(filename) {
-        const extension = filename.split('.').pop().toLowerCase();
-        const types = {
-            'mdp': 'GROMACS MDP',
-            'pbs': 'PBS Script',
-            'sh': 'Shell Script',
-            'gro': 'GROMACS Structure',
-            'top': 'GROMACS Topology',
-            'xvg': 'GROMACS Data'
-        };
-        return types[extension] || 'Text File';
-    }
-
-    getFileIcon(filename) {
-        const extension = filename.split('.').pop().toLowerCase();
-        const icons = {
-            'mdp': 'fa-cogs',
-            'pbs': 'fa-tasks',
-            'sh': 'fa-terminal',
-            'gro': 'fa-cube',
-            'top': 'fa-sitemap',
-            'xvg': 'fa-chart-line'
-        };
-        return icons[extension] || 'fa-file';
-    }
-
-    formatFileSize(bytes) {
-        if (bytes < 1024) return bytes + ' B';
-        if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
-        return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
-    }
-
-    previewFile(filename) {
-        const content = this.generatedFiles[filename];
-        const previewWindow = window.open('', '_blank', 'width=800,height=600');
-        previewWindow.document.write(`
-            <html>
-                <head>
-                    <title>Preview: ${filename}</title>
-                    <style>
-                        body { font-family: monospace; margin: 20px; background: #f5f5f5; }
-                        pre { background: white; padding: 20px; border-radius: 5px; box-shadow: 0 2px 5px rgba(0,0,0,0.1); }
-                        h1 { color: #333; }
-                    </style>
-                </head>
-                <body>
-                    <h1>${filename}</h1>
-                    <pre>${content}</pre>
-                </body>
-            </html>
-        `);
-    }
-
-    downloadFile(filename) {
-        const content = this.generatedFiles[filename];
-        const blob = new Blob([content], { type: 'text/plain' });
-        const url = URL.createObjectURL(blob);
-        const a = document.createElement('a');
-        a.href = url;
-        a.download = filename;
-        document.body.appendChild(a);
-        a.click();
-        document.body.removeChild(a);
-        URL.revokeObjectURL(url);
-    }
-
-    async previewFiles() {
-        try {
-            const resp = await fetch('/api/get-generated-files');
-            const data = await resp.json();
-            if (!data.success) {
-                alert('❌ Error: ' + (data.error || 'Unable to load files'));
-                return;
-            }
-            const filesList = document.getElementById('files-list');
-            if (!filesList) return;
-            filesList.innerHTML = '';
-            
-            // Store file contents for modal display
-            this.fileContents = data.files;
-            
-            Object.entries(data.files).forEach(([name, content]) => {
-                const fileItem = document.createElement('div');
-                fileItem.className = 'file-item';
-                fileItem.style.cssText = 'padding: 10px; margin: 5px 0; border: 1px solid #ddd; border-radius: 5px; cursor: pointer; background: #f9f9f9;';
-                fileItem.innerHTML = `<strong>${name}</strong>`;
-                fileItem.onclick = () => this.showFileContent(name, content);
-                filesList.appendChild(fileItem);
-            });
-            
-            // Reveal preview and download areas
-            const preview = document.getElementById('files-preview');
-            if (preview) preview.style.display = 'block';
-            const dl = document.getElementById('download-section');
-            if (dl) dl.style.display = 'block';
-            this.switchTab('file-generation');
-        } catch (e) {
-            console.error('Preview error:', e);
-            alert('❌ Failed to preview files: ' + e.message);
-        }
-    }
-
-    showFileContent(filename, content) {
-        // Create modal if it doesn't exist
-        let modal = document.getElementById('file-content-modal');
-        if (!modal) {
-            modal = document.createElement('div');
-            modal.id = 'file-content-modal';
-            modal.style.cssText = `
-                position: fixed; top: 0; left: 0; width: 100%; height: 100%; 
-                background: rgba(0,0,0,0.5); z-index: 1000; display: none;
-            `;
-            modal.innerHTML = `
-                <div style="position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%);
-                           background: white; border-radius: 10px; padding: 20px; max-width: 80%; max-height: 80%;
-                           overflow: auto; box-shadow: 0 4px 20px rgba(0,0,0,0.3);">
-                    <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 15px;">
-                        <h3 id="modal-filename" style="margin: 0; color: #333;"></h3>
-                        <button id="close-modal" style="background: #dc3545; color: white; border: none; 
-                                border-radius: 5px; padding: 8px 15px; cursor: pointer;">Close</button>
-                    </div>
-                    <pre id="modal-content" style="background: #f8f9fa; padding: 15px; border-radius: 5px; 
-                         overflow: auto; max-height: 60vh; white-space: pre-wrap; font-family: monospace;"></pre>
-                </div>
-            `;
-            document.body.appendChild(modal);
-            
-            // Close modal handlers
-            document.getElementById('close-modal').onclick = () => modal.style.display = 'none';
-            modal.onclick = (e) => {
-                if (e.target === modal) modal.style.display = 'none';
-            };
-        }
-        
-        // Populate and show modal
-        document.getElementById('modal-filename').textContent = filename;
-        document.getElementById('modal-content').textContent = content;
-        modal.style.display = 'block';
-    }
-
-    async downloadZip() {
-        try {
-            const resp = await fetch('/api/download-output-zip');
-            if (!resp.ok) {
-                const text = await resp.text();
-                throw new Error(text || 'Failed to create ZIP');
-            }
-            const blob = await resp.blob();
-            const url = window.URL.createObjectURL(blob);
-            const a = document.createElement('a');
-            a.href = url;
-            a.download = 'output.zip';
-            document.body.appendChild(a);
-            a.click();
-            a.remove();
-            window.URL.revokeObjectURL(url);
-        } catch (e) {
-            console.error('Download error:', e);
-            alert('❌ Failed to download ZIP: ' + e.message);
-        }
-    }
-
-    async previewSolvatedProtein() {
-        try {
-            // Show loading state
-            const button = document.getElementById('preview-solvated');
-            const originalText = button.innerHTML;
-            button.innerHTML = '<i class="fas fa-spinner fa-spin"></i> Loading...';
-            button.disabled = true;
-
-            // Fetch a single viewer PDB that marks ligands as HETATM within protein_solvated frame
-            const response = await fetch('/api/get-viewer-pdb');
-            if (!response.ok) {
-                throw new Error('Viewer PDB not available. Please generate files first.');
-            }
-
-            const data = await response.json();
-            if (!data.success) {
-                throw new Error(data.error || 'Failed to load viewer PDB');
-            }
-
-            // Open the dedicated viewer page (bypasses CSP issues)
-            window.open('/viewer/viewer_protein_with_ligand.pdb', '_blank');
-
-        } catch (error) {
-            console.error('Error previewing solvated protein:', error);
-            alert('❌ Error: ' + error.message);
-        } finally {
-            // Restore button state
-            const button = document.getElementById('preview-solvated');
-            button.innerHTML = '<i class="fas fa-tint"></i> Preview Solvated Protein';
-            button.disabled = false;
-        }
-    }
-
-    
-
-    displaySimulationSummary() {
-        const summaryContent = document.getElementById('summary-content');
-        const params = this.simulationParams;
-        const protein = this.currentProtein;
-        
-        const totalTime = (params.steps.production.steps * params.timestep) / 1000; // Convert to ns
-        
-        summaryContent.innerHTML = `
-            <div class="summary-item">
-                <h4>Protein Information</h4>
-                <p><strong>Structure ID:</strong> ${protein.structureId}</p>
-                <p><strong>Atoms:</strong> ${protein.atomCount.toLocaleString()}</p>
-                <p><strong>Chains:</strong> ${protein.chains.join(', ')}</p>
-                <p><strong>Residues:</strong> ${protein.residueCount.toLocaleString()}</p>
-            </div>
-            <div class="summary-item">
-                <h4>System Components</h4>
-                <p><strong>Water molecules:</strong> ${protein.waterMolecules.toLocaleString()}</p>
-                <p><strong>Ions:</strong> ${protein.ions.toLocaleString()}</p>
-                <p><strong>Ligands:</strong> ${protein.ligands.length > 0 ? protein.ligands.join(', ') : 'None'}</p>
-                <p><strong>HETATM entries:</strong> ${protein.hetatoms.toLocaleString()}</p>
-            </div>
-            <div class="summary-item">
-                <h4>Simulation Box</h4>
-                <p><strong>Type:</strong> ${params.boxType}</p>
-                <p><strong>Size:</strong> ${params.boxSize} nm</p>
-                <p><strong>Margin:</strong> ${params.boxMargin} nm</p>
-            </div>
-            <div class="summary-item">
-                <h4>Force Field & Water</h4>
-                <p><strong>Force Field:</strong> ${params.forceField}</p>
-                <p><strong>Water Model:</strong> ${params.waterModel}</p>
-                <p><strong>Ion Conc.:</strong> ${params.ionConcentration} mM</p>
-            </div>
-            <div class="summary-item">
-                <h4>Simulation Parameters</h4>
-                <p><strong>Temperature:</strong> ${params.temperature} K</p>
-                <p><strong>Pressure:</strong> ${params.pressure} bar</p>
-                <p><strong>Time Step:</strong> ${params.timestep} ps</p>
-            </div>
-            <div class="summary-item">
-                <h4>Simulation Time</h4>
-                <p><strong>Total Time:</strong> ${totalTime.toFixed(2)} ns</p>
-                <p><strong>Steps:</strong> ${params.steps.production.steps.toLocaleString()}</p>
-                <p><strong>Output Freq:</strong> Every 5 ps</p>
-            </div>
-            <div class="summary-item">
-                <h4>Generated Files</h4>
-                <p><strong>MDP Files:</strong> 6</p>
-                <p><strong>Scripts:</strong> 3</p>
-                <p><strong>Total Size:</strong> ${this.formatFileSize(Object.values(this.generatedFiles).join('').length)}</p>
-            </div>
-        `;
-    }
-
-    // 3D Visualization Methods
-    async load3DVisualization() {
-        if (!this.currentProtein) return;
-
-        try {
-            // Initialize NGL stage if not already done
-            if (!this.nglStage) {
-                this.nglStage = new NGL.Stage("ngl-viewer", {
-                    backgroundColor: "white",
-                    quality: "medium"
-                });
-            }
-
-            // Clear existing components
-            this.nglStage.removeAllComponents();
-
-            // Create a blob from PDB content
-            const blob = new Blob([this.currentProtein.content], { type: 'text/plain' });
-            const url = URL.createObjectURL(blob);
-
-            // Load the structure
-            const component = await this.nglStage.loadFile(url, {
-                ext: "pdb",
-                defaultRepresentation: false
-            });
-
-            // Add cartoon representation for protein with chain-based colors
-            component.addRepresentation("cartoon", {
-                sele: "protein",
-                colorScheme: "chainname",
-                opacity: 0.9
-            });
-
-            // Add ball and stick for water molecules
-            if (this.currentProtein.waterMolecules > 0) {
-                component.addRepresentation("ball+stick", {
-                    sele: "water",
-                    color: "cyan",
-                    colorScheme: "uniform",
-                    radius: 0.1
-                });
-            }
-
-            // Add ball and stick for ions
-            if (this.currentProtein.ions > 0) {
-                component.addRepresentation("ball+stick", {
-                    sele: "ion",
-                    color: "element",
-                    radius: 0.2
-                });
-            }
-
-            // Add ball and stick for ligands
-            if (this.currentProtein.ligands.length > 0) {
-                component.addRepresentation("ball+stick", {
-                    sele: "hetero",
-                    color: "element",
-                    radius: 0.15
-                });
-            }
-
-            // Auto-fit the view
-            this.nglStage.autoView();
-
-            // Show controls
-            document.getElementById('viewer-controls').style.display = 'flex';
-
-            // Clean up the blob URL
-            URL.revokeObjectURL(url);
-
-        } catch (error) {
-            console.error('Error loading 3D visualization:', error);
-            this.showStatus('error', 'Error loading 3D visualization: ' + error.message);
-        }
-    }
-
-    resetView() {
-        if (this.nglStage) {
-            this.nglStage.autoView();
-        }
-    }
-
-    toggleRepresentation() {
-        if (!this.nglStage) return;
-
-        const components = this.nglStage.compList;
-        if (components.length === 0) return;
-
-        const component = components[0];
-        component.removeAllRepresentations();
-
-        if (this.currentRepresentation === 'cartoon') {
-            // Switch to ball and stick for everything
-            component.addRepresentation("ball+stick", {
-                color: "element",
-                radius: 0.15
-            });
-            this.currentRepresentation = 'ball+stick';
-            document.getElementById('style-text').textContent = 'Ball & Stick';
-        } else if (this.currentRepresentation === 'ball+stick') {
-            // Switch to surface (protein only) + ball&stick for others
-            component.addRepresentation("surface", {
-                sele: "protein",
-                colorScheme: "chainname",
-                opacity: 0.7
-            });
-
-            // Add ball and stick for water molecules
-            if (this.currentProtein.waterMolecules > 0) {
-                component.addRepresentation("ball+stick", {
-                    sele: "water",
-                    color: "cyan",
-                    colorScheme: "uniform",
-                    radius: 0.1
-                });
-            }
-
-            // Add ball and stick for ions
-            if (this.currentProtein.ions > 0) {
-                component.addRepresentation("ball+stick", {
-                    sele: "ion",
-                    color: "element",
-                    radius: 0.2
-                });
-            }
-
-            // Add ball and stick for ligands
-            if (this.currentProtein.ligands.length > 0) {
-                component.addRepresentation("ball+stick", {
-                    sele: "hetero",
-                    color: "element",
-                    radius: 0.15
-                });
-            }
-
-            this.currentRepresentation = 'surface';
-            document.getElementById('style-text').textContent = 'Surface';
-        } else {
-            // Switch back to mixed representation (protein ribbon + others ball&stick)
-            component.addRepresentation("cartoon", {
-                sele: "protein",
-                colorScheme: "chainname",
-                opacity: 0.8
-            });
-
-            // Add ball and stick for water molecules
-            if (this.currentProtein.waterMolecules > 0) {
-                component.addRepresentation("ball+stick", {
-                    sele: "water",
-                    color: "cyan",
-                    colorScheme: "uniform",
-                    radius: 0.1
-                });
-            }
-
-            // Add ball and stick for ions
-            if (this.currentProtein.ions > 0) {
-                component.addRepresentation("ball+stick", {
-                    sele: "ion",
-                    color: "element",
-                    radius: 0.2
-                });
-            }
-
-            // Add ball and stick for ligands
-            if (this.currentProtein.ligands.length > 0) {
-                component.addRepresentation("ball+stick", {
-                    sele: "hetero",
-                    color: "element",
-                    radius: 0.15
-                });
-            }
-
-            this.currentRepresentation = 'cartoon';
-            document.getElementById('style-text').textContent = 'Mixed View';
-        }
-    }
-
-    toggleSpin() {
-        if (!this.nglStage) return;
-
-        this.isSpinning = !this.isSpinning;
-        this.nglStage.setSpin(this.isSpinning);
-    }
-
-    // Structure Preparation Methods
-    async prepareStructure() {
-        if (!this.currentProtein) {
-            alert('Please load a protein structure first');
-            return;
-        }
-
-        // Get preparation options
-        const options = {
-            remove_water: document.getElementById('remove-water').checked,
-            remove_ions: document.getElementById('remove-ions').checked,
-            remove_hydrogens: document.getElementById('remove-hydrogens').checked,
-            add_nme: document.getElementById('add-nme').checked,
-            add_ace: document.getElementById('add-ace').checked,
-            preserve_ligands: document.getElementById('preserve-ligands').checked,
-            separate_ligands: document.getElementById('separate-ligands').checked,
-            selected_chains: this.getSelectedChains(),
-            selected_ligands: this.getSelectedLigands()
-        };
-
-        // Show status
-        document.getElementById('prep-status').style.display = 'block';
-        document.getElementById('prep-status-content').innerHTML = `
-            <p><i class="fas fa-spinner fa-spin"></i> Preparing structure...</p>
-        `;
-
-        try {
-            // Call Python backend
-            const response = await fetch('/api/prepare-structure', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    pdb_content: this.currentProtein.content,
-                    options: options
-                })
-            });
-
-            const result = await response.json();
-
-            if (result.success) {
-                // Store prepared structure
-                this.preparedProtein = {
-                    content: result.prepared_structure,
-                    original_atoms: result.original_atoms,
-                    prepared_atoms: result.prepared_atoms,
-                    removed_components: result.removed_components,
-                    added_capping: result.added_capping,
-                    preserved_ligands: result.preserved_ligands,
-                    ligand_present: result.ligand_present,
-                    separate_ligands: result.separate_ligands,
-                    ligand_content: result.ligand_content || ''
-                };
-
-                // Format removed components
-                const removedText = result.removed_components ? 
-                    Object.entries(result.removed_components)
-                        .filter(([key, value]) => value > 0)
-                        .map(([key, value]) => `${key}: ${value}`)
-                        .join(', ') || 'None' : 'None';
-                
-                // Format added capping
-                const addedText = result.added_capping ? 
-                    Object.entries(result.added_capping)
-                        .filter(([key, value]) => value > 0)
-                        .map(([key, value]) => `${key}: ${value}`)
-                        .join(', ') || 'None' : 'None';
-
-                // Update status
-                document.getElementById('prep-status-content').innerHTML = `
-                    <p><i class="fas fa-check-circle"></i> Structure preparation completed!</p>
-                    <p><strong>Original atoms:</strong> ${result.original_atoms.toLocaleString()}</p>
-                    <p><strong>Prepared atoms:</strong> ${result.prepared_atoms.toLocaleString()}</p>
-                    <p><strong>Removed:</strong> ${removedText}</p>
-                    <p><strong>Added:</strong> ${addedText}</p>
-                    <p><strong>Ligands:</strong> ${result.preserved_ligands}</p>
-                    <p>Ready for AMBER force field generation!</p>
-                `;
-
-                // Enable preview and download buttons
-                document.getElementById('preview-prepared').disabled = false;
-                document.getElementById('download-prepared').disabled = false;
-                
-                // Enable ligand download button if ligands are present and separate ligands is checked
-                const separateLigandsChecked = document.getElementById('separate-ligands').checked;
-                const downloadLigandBtn = document.getElementById('download-ligand');
-                if (result.ligand_present && separateLigandsChecked && result.ligand_content) {
-                    downloadLigandBtn.disabled = false;
-                    downloadLigandBtn.classList.remove('btn-outline-secondary');
-                    downloadLigandBtn.classList.add('btn-outline-primary');
-                } else {
-                    downloadLigandBtn.disabled = true;
-                    downloadLigandBtn.classList.remove('btn-outline-primary');
-                    downloadLigandBtn.classList.add('btn-outline-secondary');
-                }
-
-                // Show ligand force field group if preserve ligands is checked
-                const preserveLigandsChecked = document.getElementById('preserve-ligands').checked;
-                if (preserveLigandsChecked && result.ligand_present) {
-                    this.toggleLigandForceFieldGroup(true);
-                }
-            } else {
-                throw new Error(result.error || 'Structure preparation failed');
-            }
-        } catch (error) {
-            console.error('Error preparing structure:', error);
-            document.getElementById('prep-status-content').innerHTML = `
-                <p><i class="fas fa-exclamation-triangle"></i> Error preparing structure</p>
-                <p>${error.message}</p>
-            `;
-        }
-    }
-
-    renderChainAndLigandSelections() {
-        if (!this.currentProtein) return;
-        // Render chains
-        const chainContainer = document.getElementById('chain-selection');
-        if (chainContainer) {
-            chainContainer.innerHTML = '';
-            this.currentProtein.chains.forEach(chainId => {
-                const id = `chain-${chainId}`;
-                const wrapper = document.createElement('div');
-                wrapper.className = 'checkbox-inline';
-                wrapper.innerHTML = `
-                    <label class="checkbox-container">
-                        <input type="checkbox" id="${id}" data-chain="${chainId}">
-                        <span class="checkmark"></span>
-                        Chain ${chainId}
-                    </label>`;
-                chainContainer.appendChild(wrapper);
-            });
-        }
-
-        // Render ligands (RESN-CHAIN groups)
-        const ligandContainer = document.getElementById('ligand-selection');
-        if (ligandContainer) {
-            ligandContainer.innerHTML = '';
-            if (Array.isArray(this.currentProtein.ligandGroups) && this.currentProtein.ligandGroups.length > 0) {
-                this.currentProtein.ligandGroups.forEach(l => {
-                    const key = `${l.resn}-${l.chain}`;
-                    const id = `lig-${key}`;
-                    const wrapper = document.createElement('div');
-                    wrapper.className = 'checkbox-inline';
-                    wrapper.innerHTML = `
-                        <label class="checkbox-container">
-                            <input type="checkbox" id="${id}" data-resn="${l.resn}" data-chain="${l.chain}">
-                            <span class="checkmark"></span>
-                            ${key}
-                        </label>`;
-                    ligandContainer.appendChild(wrapper);
-                });
-            } else {
-                // Fallback: show unique ligand names if detailed positions not parsed
-                if (Array.isArray(this.currentProtein.ligands) && this.currentProtein.ligands.length > 0) {
-                    this.currentProtein.ligands.forEach(resn => {
-                        const id = `lig-${resn}`;
-                        const wrapper = document.createElement('div');
-                        wrapper.className = 'checkbox-inline';
-                        wrapper.innerHTML = `
-                            <label class="checkbox-container">
-                                <input type="checkbox" id="${id}" data-resn="${resn}">
-                                <span class="checkmark"></span>
-                                ${resn}
-                            </label>`;
-                        ligandContainer.appendChild(wrapper);
-                    });
-                } else {
-                    ligandContainer.innerHTML = '<small>No ligands detected</small>';
-                }
-            }
-        }
-    }
-
-    getSelectedChains() {
-        const container = document.getElementById('chain-selection');
-        if (!container) return [];
-        return Array.from(container.querySelectorAll('input[type="checkbox"]:checked')).map(cb => cb.getAttribute('data-chain'));
-    }
-
-    getSelectedLigands() {
-        const container = document.getElementById('ligand-selection');
-        if (!container) return [];
-        return Array.from(container.querySelectorAll('input[type="checkbox"]:checked')).map(cb => ({
-            resn: cb.getAttribute('data-resn') || '',
-            chain: cb.getAttribute('data-chain') || ''
-        }));
-    }
-
-    previewPreparedStructure() {
-        if (!this.preparedProtein) {
-            alert('Please prepare a protein structure first');
-            return;
-        }
-
-        // Show prepared structure preview
-        document.getElementById('prepared-structure-preview').style.display = 'block';
-        
-        // Format removed components
-        const removedText = this.preparedProtein.removed_components ? 
-            Object.entries(this.preparedProtein.removed_components)
-                .filter(([key, value]) => value > 0)
-                .map(([key, value]) => `${key}: ${value}`)
-                .join(', ') || 'None' : 'None';
-        
-        // Format added capping
-        const addedText = this.preparedProtein.added_capping ? 
-            Object.entries(this.preparedProtein.added_capping)
-                .filter(([key, value]) => value > 0)
-                .map(([key, value]) => `${key}: ${value}`)
-                .join(', ') || 'None' : 'None';
-        
-        // Update structure info
-        document.getElementById('original-atoms').textContent = this.preparedProtein.original_atoms.toLocaleString();
-        document.getElementById('prepared-atoms').textContent = this.preparedProtein.prepared_atoms.toLocaleString();
-        document.getElementById('removed-components').textContent = removedText;
-        document.getElementById('added-capping').textContent = addedText;
-        document.getElementById('preserved-ligands').textContent = this.preparedProtein.preserved_ligands;
-
-        // Load 3D visualization of prepared structure
-        this.loadPrepared3DVisualization();
-    }
-
-    downloadPreparedStructure() {
-        if (!this.preparedProtein) {
-            alert('Please prepare a structure first');
-            return;
-        }
-
-        // Download prepared structure
-        const blob = new Blob([this.preparedProtein.content], { type: 'text/plain' });
-        const url = URL.createObjectURL(blob);
-        const a = document.createElement('a');
-        a.href = url;
-        a.download = `tleap_ready.pdb`;
-        document.body.appendChild(a);
-        a.click();
-        document.body.removeChild(a);
-        URL.revokeObjectURL(url);
-    }
-
-    downloadLigandFile() {
-        if (!this.preparedProtein || !this.preparedProtein.ligand_present || !this.preparedProtein.ligand_content) {
-            alert('No ligand file available. Please prepare structure with separate ligands enabled.');
-            return;
-        }
-
-        // Download ligand file
-        const ligandBlob = new Blob([this.preparedProtein.ligand_content], { type: 'text/plain' });
-        const ligandUrl = URL.createObjectURL(ligandBlob);
-        const ligandA = document.createElement('a');
-        ligandA.href = ligandUrl;
-        ligandA.download = `4_ligands_corrected.pdb`;
-        document.body.appendChild(ligandA);
-        ligandA.click();
-        document.body.removeChild(ligandA);
-        URL.revokeObjectURL(ligandUrl);
-    }
-
-    // 3D Visualization for prepared structure
-    async loadPrepared3DVisualization() {
-        if (!this.preparedProtein) return;
-
-        try {
-            // Initialize NGL stage for prepared structure if not already done
-            if (!this.preparedNglStage) {
-                this.preparedNglStage = new NGL.Stage("prepared-ngl-viewer", {
-                    backgroundColor: "white",
-                    quality: "medium"
-                });
-            }
-
-            // Clear existing components
-            this.preparedNglStage.removeAllComponents();
-
-            // Create a blob from prepared PDB content
-            const blob = new Blob([this.preparedProtein.content], { type: 'text/plain' });
-            const url = URL.createObjectURL(blob);
-
-            // Load the prepared structure
-            const component = await this.preparedNglStage.loadFile(url, {
-                ext: "pdb",
-                defaultRepresentation: false
-            });
-
-            // Add cartoon representation for protein with chain-based colors
-            component.addRepresentation("cartoon", {
-                sele: "protein",
-                colorScheme: "chainname",
-                opacity: 0.9
-            });
-
-            // Add ball and stick for ligands (if any) - check for HETATM records
-            component.addRepresentation("ball+stick", {
-                sele: "hetero",
-                color: "element",
-                radius: 0.2,
-                opacity: 0.8
-            });
-
-            // Auto-fit the view
-            this.preparedNglStage.autoView();
-
-            // Show controls
-            document.getElementById('prepared-viewer-controls').style.display = 'flex';
-
-            // Clean up the blob URL
-            URL.revokeObjectURL(url);
-
-        } catch (error) {
-            console.error('Error loading prepared 3D visualization:', error);
-        }
-    }
-
-    resetPreparedView() {
-        if (this.preparedNglStage) {
-            this.preparedNglStage.autoView();
-        }
-    }
-
-    togglePreparedRepresentation() {
-        if (!this.preparedNglStage) return;
-
-        const components = this.preparedNglStage.compList;
-        if (components.length === 0) return;
-
-        const component = components[0];
-        component.removeAllRepresentations();
-
-        if (this.preparedRepresentation === 'cartoon') {
-            // Switch to ball and stick
-            component.addRepresentation("ball+stick", {
-                color: "element",
-                radius: 0.15
-            });
-            this.preparedRepresentation = 'ball+stick';
-            document.getElementById('prepared-style-text').textContent = 'Ball & Stick';
-        } else if (this.preparedRepresentation === 'ball+stick') {
-            // Switch to surface
-            component.addRepresentation("surface", {
-                sele: "protein",
-                colorScheme: "chainname",
-                opacity: 0.7
-            });
-            this.preparedRepresentation = 'surface';
-            document.getElementById('prepared-style-text').textContent = 'Surface';
-        } else {
-            // Switch back to cartoon
-            component.addRepresentation("cartoon", {
-                sele: "protein",
-                colorScheme: "chainname",
-                opacity: 0.8
-            });
-
-            // Add ball and stick for ligands
-            if (this.preparedProtein.preserved_ligands !== 'None') {
-                component.addRepresentation("ball+stick", {
-                    sele: "hetero",
-                    color: "element",
-                    radius: 0.15
-                });
-            }
-
-            this.preparedRepresentation = 'cartoon';
-            document.getElementById('prepared-style-text').textContent = 'Mixed View';
-        }
-    }
-
-    togglePreparedSpin() {
-        if (!this.preparedNglStage) return;
-
-        this.preparedIsSpinning = !this.preparedIsSpinning;
-        this.preparedNglStage.setSpin(this.preparedIsSpinning);
-    }
-}
-
-// Initialize the application when the page loads
-function initializeApp() {
-    console.log('Initializing mdPipeline...'); // Debug log
-    window.mdPipeline = new MDSimulationPipeline();
-    console.log('mdPipeline initialized:', window.mdPipeline); // Debug log
-}
-
-// Try to initialize immediately if DOM is already loaded
-if (document.readyState === 'loading') {
-    document.addEventListener('DOMContentLoaded', initializeApp);
-} else {
-    // DOM is already loaded
-    initializeApp();
-}
-
-// Add some utility functions for better UX
-function formatNumber(num) {
-    return num.toLocaleString();
-}
-
-function formatTime(seconds) {
-    const hours = Math.floor(seconds / 3600);
-    const minutes = Math.floor((seconds % 3600) / 60);
-    const secs = seconds % 60;
-    return `${hours}h ${minutes}m ${secs}s`;
-}

python/app.py

@@ -1,1706 +0,0 @@
-#!/usr/bin/env python3
-"""
-MD Simulation Pipeline - Flask Backend
-Provides API endpoints for protein processing and file generation
-"""
-
-from flask import Flask, request, jsonify, send_file, render_template, send_from_directory
-from flask_cors import CORS
-import os
-import json
-import tempfile
-import zipfile
-from pathlib import Path
-import requests
-import subprocess
-from Bio.PDB import PDBParser, PDBList
-import logging
-from structure_preparation import prepare_structure, parse_structure_info
-
-app = Flask(__name__, 
-            template_folder='../html',
-            static_folder='../',
-            static_url_path='')
-CORS(app)
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Create output directory
-OUTPUT_DIR = Path(__file__).parent.parent / "output"
-
-def clean_and_create_output_folder():
-    """Clean existing output folder and create a new one"""
-    try:
-        print(f"DEBUG: Starting cleanup. OUTPUT_DIR = {OUTPUT_DIR}")
-        print(f"DEBUG: OUTPUT_DIR.exists() = {OUTPUT_DIR.exists()}")
-        
-        # Remove existing output folder if it exists
-        if OUTPUT_DIR.exists():
-            import shutil
-            print(f"DEBUG: Removing existing output folder: {OUTPUT_DIR}")
-            shutil.rmtree(OUTPUT_DIR)
-            print(f"DEBUG: Successfully removed output folder")
-            logger.info(f"Removed existing output folder: {OUTPUT_DIR}")
-        
-        # Create new output folder
-        print(f"DEBUG: Creating new output folder: {OUTPUT_DIR}")
-        OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
-        print(f"DEBUG: Successfully created output folder")
-        logger.info(f"Created new output folder: {OUTPUT_DIR}")
-        
-        return True
-    except Exception as e:
-        print(f"DEBUG: Error in cleanup: {str(e)}")
-        logger.error(f"Error cleaning output folder: {str(e)}")
-        return False
-
-class MDSimulationGenerator:
-    """Handles MD simulation file generation and protein processing"""
-    
-    def __init__(self):
-        self.pdb_parser = PDBParser(QUIET=True)
-        self.pdb_list = PDBList()
-    
-    def fetch_pdb_structure(self, pdb_id):
-        """Fetch PDB structure from RCSB"""
-        try:
-            # Download PDB file
-            pdb_file = self.pdb_list.retrieve_pdb_file(pdb_id, pdir=OUTPUT_DIR, file_format='pdb')
-            return str(pdb_file)
-        except Exception as e:
-            logger.error(f"Error fetching PDB {pdb_id}: {str(e)}")
-            raise
-    
-    def parse_pdb_structure(self, pdb_file):
-        """Parse PDB file and extract structure information"""
-        try:
-            structure = self.pdb_parser.get_structure('protein', pdb_file)
-            
-            # Extract basic information
-            atom_count = 0
-            chains = set()
-            residues = set()
-            
-            for model in structure:
-                for chain in model:
-                    chains.add(chain.id)
-                    for residue in chain:
-                        if residue.id[0] == ' ':  # Standard residues
-                            residues.add(f"{residue.resname}{residue.id[1]}")
-                        for atom in residue:
-                            atom_count += 1
-            
-            return {
-                'atom_count': atom_count,
-                'chains': list(chains),
-                'residue_count': len(residues),
-                'structure_id': Path(pdb_file).stem.upper()
-            }
-        except Exception as e:
-            logger.error(f"Error parsing PDB file: {str(e)}")
-            raise
-    
-    def generate_mdp_file(self, params, step_type='production'):
-        """Generate GROMACS MDP file for different simulation steps"""
-        
-        if step_type == 'restrained_min':
-            return f"""; Restrained Minimization Parameters
-integrator = steep
-nsteps = {params['steps']['restrainedMin']['steps']}
-emstep = 0.01
-emtol = 1000
-
-; Position restraints
-define = -DPOSRES
-refcoord_scaling = com
-
-; Output control
-nstxout = 100
-nstenergy = 100
-nstlog = 100
-
-; Bond parameters
-constraint_algorithm = lincs
-constraints = h-bonds
-
-; Neighbor searching
-cutoff-scheme = Verlet
-ns_type = grid
-nstlist = 10
-rlist = {params['cutoff']}
-
-; Electrostatics
-coulombtype = PME
-rcoulomb = {params['cutoff']}
-pme_order = {params['pmeOrder']}
-
-; Van der Waals
-vdwtype = Cut-off
-rvdw = {params['cutoff']}
-"""
-        
-        elif step_type == 'minimization':
-            return f"""; Minimization Parameters
-integrator = {params['steps']['minimization']['algorithm']}
-nsteps = {params['steps']['minimization']['steps']}
-emstep = 0.01
-emtol = 1000
-
-; Output control
-nstxout = 100
-nstenergy = 100
-nstlog = 100
-
-; Bond parameters
-constraint_algorithm = lincs
-constraints = h-bonds
-
-; Neighbor searching
-cutoff-scheme = Verlet
-ns_type = grid
-nstlist = 10
-rlist = {params['cutoff']}
-
-; Electrostatics
-coulombtype = PME
-rcoulomb = {params['cutoff']}
-pme_order = {params['pmeOrder']}
-
-; Van der Waals
-vdwtype = Cut-off
-rvdw = {params['cutoff']}
-"""
-        
-        elif step_type == 'nvt':
-            return f"""; NVT Equilibration Parameters
-integrator = md
-dt = {params['timestep']}
-nsteps = {params['steps']['nvt']['steps']}
-
-; Output control
-nstxout = 5000
-nstvout = 5000
-nstenergy = 1000
-nstlog = 1000
-
-; Bond parameters
-constraint_algorithm = lincs
-constraints = h-bonds
-lincs_iter = 1
-lincs_order = 4
-
-; Neighbor searching
-cutoff-scheme = Verlet
-ns_type = grid
-nstlist = 40
-rlist = {params['cutoff']}
-
-; Electrostatics
-coulombtype = PME
-rcoulomb = {params['cutoff']}
-pme_order = {params['pmeOrder']}
-
-; Van der Waals
-vdwtype = Cut-off
-rvdw = {params['cutoff']}
-
-; Temperature coupling
-tcoupl = {params['couplingType']}
-tc-grps = Protein Non-Protein
-tau_t = 0.1 0.1
-ref_t = {params['steps']['nvt']['temperature']} {params['steps']['nvt']['temperature']}
-
-; Pressure coupling (disabled for NVT)
-pcoupl = no
-
-; Velocity generation
-gen_vel = yes
-gen_temp = {params['steps']['nvt']['temperature']}
-gen_seed = -1
-"""
-        
-        elif step_type == 'npt':
-            return f"""; NPT Equilibration Parameters
-integrator = md
-dt = {params['timestep']}
-nsteps = {params['steps']['npt']['steps']}
-
-; Output control
-nstxout = 5000
-nstvout = 5000
-nstenergy = 1000
-nstlog = 1000
-
-; Bond parameters
-constraint_algorithm = lincs
-constraints = h-bonds
-lincs_iter = 1
-lincs_order = 4
-
-; Neighbor searching
-cutoff-scheme = Verlet
-ns_type = grid
-nstlist = 40
-rlist = {params['cutoff']}
-
-; Electrostatics
-coulombtype = PME
-rcoulomb = {params['cutoff']}
-pme_order = {params['pmeOrder']}
-
-; Van der Waals
-vdwtype = Cut-off
-rvdw = {params['cutoff']}
-
-; Temperature coupling
-tcoupl = {params['couplingType']}
-tc-grps = Protein Non-Protein
-tau_t = 0.1 0.1
-ref_t = {params['steps']['npt']['temperature']} {params['steps']['npt']['temperature']}
-
-; Pressure coupling
-pcoupl = {params['couplingType']}
-pcoupltype = isotropic
-tau_p = 2.0
-ref_p = {params['steps']['npt']['pressure']}
-compressibility = 4.5e-5
-
-; Velocity generation
-gen_vel = no
-"""
-        
-        else:  # production
-            return f"""; MD Simulation Parameters
-; Generated by MD Simulation Pipeline
-
-; Run parameters
-integrator = md
-dt = {params['timestep']}
-nsteps = {params['steps']['production']['steps']}
-
-; Output control
-nstxout = 5000
-nstvout = 5000
-nstenergy = 1000
-nstlog = 1000
-
-; Bond parameters
-constraint_algorithm = lincs
-constraints = h-bonds
-lincs_iter = 1
-lincs_order = 4
-
-; Neighbor searching
-cutoff-scheme = Verlet
-ns_type = grid
-nstlist = 40
-rlist = {params['cutoff']}
-
-; Electrostatics
-coulombtype = PME
-rcoulomb = {params['cutoff']}
-pme_order = {params['pmeOrder']}
-fourierspacing = 0.16
-
-; Van der Waals
-vdwtype = Cut-off
-rvdw = {params['cutoff']}
-
-; Temperature coupling
-tcoupl = {params['couplingType']}
-tc-grps = Protein Non-Protein
-tau_t = 0.1 0.1
-ref_t = {params['temperature']} {params['temperature']}
-
-; Pressure coupling
-pcoupl = {params['couplingType']}
-pcoupltype = isotropic
-tau_p = 2.0
-ref_p = {params['pressure']}
-compressibility = 4.5e-5
-
-; Dispersion correction
-DispCorr = EnerPres
-
-; Velocity generation
-gen_vel = yes
-gen_temp = {params['temperature']}
-gen_seed = -1
-"""
-    
-    def generate_pbs_script(self, protein_name, params):
-        """Generate PBS script for HPC submission"""
-        total_steps = params['steps']['production']['steps']
-        time_in_ns = (total_steps * params['timestep']) / 1000
-        
-        return f"""#!/bin/bash
-#PBS -N {protein_name}_md
-#PBS -l nodes=1:ppn=16
-#PBS -l walltime=24:00:00
-#PBS -q normal
-#PBS -j oe
-
-# Change to the directory where the job was submitted
-cd $PBS_O_WORKDIR
-
-# Load required modules
-module load gromacs/2023.2
-module load intel/2021.4.0
-
-# Set up environment
-export OMP_NUM_THREADS=16
-export GMX_MAXBACKUP=-1
-
-# Simulation parameters
-PROTEIN={protein_name}
-STEPS={total_steps}
-TIME_NS={time_in_ns:.2f}
-
-echo "Starting MD simulation for $PROTEIN"
-echo "Total simulation time: $TIME_NS ns"
-echo "Job started at: $(date)"
-
-# Run the simulation
-./run_simulation.sh $PROTEIN
-
-echo "Simulation completed at: $(date)"
-echo "Results saved in output directory"
-"""
-    
-    def generate_setup_script(self, protein_name, params):
-        """Generate setup script for MD simulation"""
-        return f"""#!/bin/bash
-# Setup script for {protein_name} MD simulation
-# Generated by MD Simulation Pipeline
-
-set -e
-
-PROTEIN={protein_name}
-FORCE_FIELD={params['forceField']}
-WATER_MODEL={params['waterModel']}
-
-echo "Setting up MD simulation for $PROTEIN"
-
-# Create output directory
-mkdir -p output
-
-# 1. Prepare protein structure
-echo "Preparing protein structure..."
-gmx pdb2gmx -f $PROTEIN.pdb -o $PROTEIN_processed.gro -p $PROTEIN.top -ff $FORCE_FIELD -water $WATER_MODEL
-
-# 2. Define simulation box
-echo "Defining simulation box..."
-gmx editconf -f $PROTEIN_processed.gro -o $PROTEIN_box.gro -c -d {params['boxMargin']} -bt {params['boxType']}
-
-# 3. Add solvent
-echo "Adding solvent..."
-gmx solvate -cp $PROTEIN_box.gro -cs spc216.gro -o $PROTEIN_solv.gro -p $PROTEIN.top
-
-# 4. Add ions
-echo "Adding ions..."
-gmx grompp -f $PROTEIN_restrained.mdp -c $PROTEIN_solv.gro -p $PROTEIN.top -o $PROTEIN_ions.tpr
-echo "SOL" | gmx genion -s $PROTEIN_ions.tpr -o $PROTEIN_final.gro -p $PROTEIN.top -pname NA -nname CL -neutral
-
-echo "Setup completed successfully!"
-echo "Ready to run simulation with: ./run_simulation.sh $PROTEIN"
-"""
-    
-    def generate_analysis_script(self, protein_name):
-        """Generate analysis script for MD simulation results"""
-        return f"""#!/bin/bash
-# Analysis script for {protein_name} MD simulation
-# Generated by MD Simulation Pipeline
-
-PROTEIN={protein_name}
-
-echo "Analyzing MD simulation results for $PROTEIN"
-
-# Create analysis directory
-mkdir -p analysis
-
-# 1. RMSD analysis
-echo "Calculating RMSD..."
-echo "Protein" | gmx rms -s $PROTEIN_final.tpr -f $PROTEIN_prod.xtc -o analysis/$PROTEIN_rmsd.xvg -tu ns
-
-# 2. RMSF analysis
-echo "Calculating RMSF..."
-echo "Protein" | gmx rmsf -s $PROTEIN_final.tpr -f $PROTEIN_prod.xtc -o analysis/$PROTEIN_rmsf.xvg -res
-
-# 3. Radius of gyration
-echo "Calculating radius of gyration..."
-echo "Protein" | gmx gyrate -s $PROTEIN_final.tpr -f $PROTEIN_prod.xtc -o analysis/$PROTEIN_gyrate.xvg
-
-# 4. Hydrogen bonds
-echo "Analyzing hydrogen bonds..."
-echo "Protein" | gmx hbond -s $PROTEIN_final.tpr -f $PROTEIN_prod.xtc -num analysis/$PROTEIN_hbonds.xvg
-
-# 5. Energy analysis
-echo "Analyzing energies..."
-gmx energy -f $PROTEIN_prod.edr -o analysis/$PROTEIN_energy.xvg
-
-# 6. Generate plots
-echo "Generating analysis plots..."
-python3 plot_analysis.py $PROTEIN
-
-echo "Analysis completed! Results saved in analysis/ directory"
-"""
-
-# Initialize the MD simulation generator
-md_generator = MDSimulationGenerator()
-
-@app.route('/api/fetch-pdb', methods=['POST'])
-def fetch_pdb():
-    """Fetch PDB structure from RCSB"""
-    try:
-        print("DEBUG: fetch-pdb endpoint called")
-        data = request.get_json()
-        pdb_id = data.get('pdb_id', '').upper()
-        print(f"DEBUG: pdb_id = {pdb_id}")
-        
-        if not pdb_id or len(pdb_id) != 4:
-            return jsonify({'error': 'Invalid PDB ID'}), 400
-        
-        # Clean and create new output folder for fresh start
-        print("DEBUG: Calling clean_and_create_output_folder()")
-        if not clean_and_create_output_folder():
-            return jsonify({'error': 'Failed to clean output folder'}), 500
-        print("DEBUG: Output folder cleanup completed successfully")
-        
-        # Fetch PDB structure
-        pdb_file = md_generator.fetch_pdb_structure(pdb_id)
-        
-        # Parse structure information
-        structure_info = md_generator.parse_pdb_structure(pdb_file)
-        
-        return jsonify({
-            'success': True,
-            'structure_info': structure_info,
-            'pdb_file': pdb_file
-        })
-    
-    except Exception as e:
-        logger.error(f"Error fetching PDB: {str(e)}")
-        return jsonify({'error': str(e)}), 500
-
-@app.route('/api/parse-pdb', methods=['POST'])
-def parse_pdb():
-    """Parse uploaded PDB file"""
-    try:
-        print("DEBUG: parse-pdb endpoint called")
-        if 'file' not in request.files:
-            return jsonify({'error': 'No file uploaded'}), 400
-        
-        file = request.files['file']
-        if file.filename == '':
-            return jsonify({'error': 'No file selected'}), 400
-        
-        print(f"DEBUG: Processing uploaded file: {file.filename}")
-        
-        # Clean and create new output folder for fresh start
-        print("DEBUG: Calling clean_and_create_output_folder()")
-        if not clean_and_create_output_folder():
-            return jsonify({'error': 'Failed to clean output folder'}), 500
-        print("DEBUG: Output folder cleanup completed successfully")
-        
-        # Save uploaded file temporarily
-        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.pdb')
-        file.save(temp_file.name)
-        
-        # Parse structure information
-        structure_info = md_generator.parse_pdb_structure(temp_file.name)
-        
-        # Clean up temporary file
-        os.unlink(temp_file.name)
-        
-        return jsonify({
-            'success': True,
-            'structure_info': structure_info
-        })
-    
-    except Exception as e:
-        logger.error(f"Error parsing PDB: {str(e)}")
-        return jsonify({'error': str(e)}), 500
-
-@app.route('/api/generate-files', methods=['POST'])
-def generate_files():
-    """Generate MD simulation files"""
-    try:
-        data = request.get_json()
-        protein_name = data.get('protein_name', 'protein')
-        simulation_params = data.get('simulation_params', {})
-        
-        # Generate all files
-        files = {}
-        
-        # MDP files
-        files[f'{protein_name}.mdp'] = md_generator.generate_mdp_file(simulation_params, 'production')
-        files[f'{protein_name}_restrained.mdp'] = md_generator.generate_mdp_file(simulation_params, 'restrained_min')
-        files[f'{protein_name}_min.mdp'] = md_generator.generate_mdp_file(simulation_params, 'minimization')
-        files[f'{protein_name}_nvt.mdp'] = md_generator.generate_mdp_file(simulation_params, 'nvt')
-        files[f'{protein_name}_npt.mdp'] = md_generator.generate_mdp_file(simulation_params, 'npt')
-        files[f'{protein_name}_prod.mdp'] = md_generator.generate_mdp_file(simulation_params, 'production')
-        
-        # Scripts
-        files[f'{protein_name}_simulation.pbs'] = md_generator.generate_pbs_script(protein_name, simulation_params)
-        files[f'setup_{protein_name}.sh'] = md_generator.generate_setup_script(protein_name, simulation_params)
-        files[f'analyze_{protein_name}.sh'] = md_generator.generate_analysis_script(protein_name)
-        
-        return jsonify({
-            'success': True,
-            'files': files
-        })
-    
-    except Exception as e:
-        logger.error(f"Error generating files: {str(e)}")
-        return jsonify({'error': str(e)}), 500
-
-@app.route('/api/download-zip', methods=['POST'])
-def download_zip():
-    """Download all generated files as a ZIP archive"""
-    try:
-        data = request.get_json()
-        files = data.get('files', {})
-        
-        # Create temporary ZIP file
-        temp_zip = tempfile.NamedTemporaryFile(delete=False, suffix='.zip')
-        
-        with zipfile.ZipFile(temp_zip.name, 'w') as zip_file:
-            for filename, content in files.items():
-                zip_file.writestr(filename, content)
-        
-        return send_file(
-            temp_zip.name,
-            as_attachment=True,
-            download_name='md_simulation_files.zip',
-            mimetype='application/zip'
-        )
-    
-    except Exception as e:
-        logger.error(f"Error creating ZIP file: {str(e)}")
-        return jsonify({'error': str(e)}), 500
-
-@app.route('/api/get-solvated-protein', methods=['GET'])
-def get_solvated_protein():
-    """Get the solvated protein PDB file content"""
-    try:
-        solvated_file = os.path.join(OUTPUT_DIR, 'protein_solvated.pdb')
-        
-        if not os.path.exists(solvated_file):
-            return jsonify({'success': False, 'error': 'Solvated protein file not found. Please generate files first.'})
-        
-        with open(solvated_file, 'r') as f:
-            content = f.read()
-        
-        return jsonify({'success': True, 'content': content})
-    except Exception as e:
-        logger.error(f"Error reading solvated protein file: {str(e)}")
-        return jsonify({'success': False, 'error': str(e)})
-
-@app.route('/api/get-viewer-pdb', methods=['GET'])
-def get_viewer_pdb():
-    """Return a single PDB for viewer: start from protein_solvated.pdb and mark ligand residues as HETATM.
-    Ligand residues are detected from 4_ligands_corrected.pdb by (resname, chain, resi) tuples; if chains/resi not present, fallback to resname matching.
-    """
-    try:
-        solvated_path = OUTPUT_DIR / 'protein_solvated.pdb'
-        lig_path = OUTPUT_DIR / '4_ligands_corrected.pdb'
-        viewer_out = OUTPUT_DIR / 'viewer_protein_with_ligand.pdb'
-
-        if not solvated_path.exists():
-            return jsonify({'success': False, 'error': 'protein_solvated.pdb not found'}), 400
-
-        # Build ligand index from corrected ligand PDB if present
-        ligand_keys = set()
-        ligand_resnames = set()
-        if lig_path.exists():
-            with open(lig_path, 'r') as lf:
-                for line in lf:
-                    if line.startswith(('ATOM', 'HETATM')):
-                        resn = line[17:20].strip()
-                        chain = line[21:22].strip()
-                        resi = line[22:26].strip()
-                        ligand_resnames.add(resn)
-                        if chain and resi:
-                            ligand_keys.add((resn, chain, resi))
-
-        # Rewrite solvated file marking matching ligand residues and ions (NA/CL) as HETATM
-        out_lines = []
-        with open(solvated_path, 'r') as sf:
-            for line in sf:
-                if line.startswith(('ATOM', 'HETATM')):
-                    resn = line[17:20].strip()
-                    chain = line[21:22].strip()
-                    resi = line[22:26].strip()
-                    is_match = False
-                    is_ion = resn in { 'NA', 'CL' }
-                    if (resn, chain, resi) in ligand_keys:
-                        is_match = True
-                    elif resn in ligand_resnames:
-                        # Fallback by residue name only
-                        is_match = True
-                    if is_match or is_ion:
-                        # Force to HETATM
-                        out_lines.append('HETATM' + line[6:])
-                    else:
-                        out_lines.append(line)
-                else:
-                    out_lines.append(line)
-
-        # Save combined viewer file (optional but useful for debugging)
-        try:
-            with open(viewer_out, 'w') as vf:
-                vf.writelines(out_lines)
-        except Exception:
-            pass
-
-        return jsonify({'success': True, 'content': ''.join(out_lines)})
-    except Exception as e:
-        logger.error(f"Error generating viewer PDB: {str(e)}")
-        return jsonify({'success': False, 'error': str(e)})
-
-@app.route('/api/get-corrected-ligands', methods=['GET'])
-def get_corrected_ligands():
-    """Get the corrected ligand PDB file content if present"""
-    try:
-        ligand_file = OUTPUT_DIR / '4_ligands_corrected.pdb'
-        if not ligand_file.exists():
-            # Return success with exists flag false so frontend can decide gracefully
-            return jsonify({'success': True, 'exists': False, 'content': ''})
-        # Read and normalize records to HETATM for viewer compatibility
-        normalized_lines = []
-        with open(ligand_file, 'r') as f:
-            for line in f:
-                if line.startswith('ATOM'):
-                    # Replace record name to HETATM, preserve fixed-width columns
-                    normalized_lines.append('HETATM' + line[6:])
-                else:
-                    normalized_lines.append(line)
-        content = ''.join(normalized_lines)
-        return jsonify({'success': True, 'exists': True, 'content': content})
-    except Exception as e:
-        logger.error(f"Error reading corrected ligand file: {str(e)}")
-        return jsonify({'success': False, 'error': str(e)})
-
-@app.route('/api/get-aligned-ligands', methods=['GET'])
-def get_aligned_ligands():
-    """Return ligand coordinates aligned to protein_solvated.pdb frame using PyMOL transforms."""
-    try:
-        solvated_file = OUTPUT_DIR / 'protein_solvated.pdb'
-        tleap_ready = OUTPUT_DIR / 'tleap_ready.pdb'
-        ligand_file = OUTPUT_DIR / '4_ligands_corrected.pdb'
-
-        if not solvated_file.exists():
-            return jsonify({'success': False, 'error': 'protein_solvated.pdb not found'}), 400
-        if not tleap_ready.exists():
-            return jsonify({'success': False, 'error': 'tleap_ready.pdb not found'}), 400
-        if not ligand_file.exists():
-            return jsonify({'success': True, 'exists': False, 'content': ''})
-
-        # Create temp output path
-        aligned_lig = OUTPUT_DIR / 'ligand_aligned_for_preview.pdb'
-        try:
-            if aligned_lig.exists():
-                aligned_lig.unlink()
-        except Exception:
-            pass
-
-        # PyMOL script: load solvated, load tlready (protein+lig), align tlready protein to solvated protein, then save transformed ligand
-        pymol_script = f"""
-import pymol
-pymol.finish_launching(['pymol','-qc'])
-from pymol import cmd
-cmd.load('{solvated_file.as_posix()}', 'solv')
-cmd.load('{tleap_ready.as_posix()}', 'prep')
-cmd.load('{ligand_file.as_posix()}', 'lig')
-# Align prepared protein to solvated protein; use CA atoms to be robust
-cmd.align('prep and polymer.protein and name CA', 'solv and polymer.protein and name CA')
-# Apply same transform implicitly affects 'prep' object; we saved ligand as separate object, so match matrices
-mat = cmd.get_object_matrix('prep')
-cmd.set_object_matrix('lig', mat)
-# Save ligand in aligned frame, as HETATM
-cmd.alter('lig', 'type="HETATM"')
-cmd.save('{aligned_lig.as_posix()}', 'lig')
-cmd.quit()
-"""
-
-        # Run PyMOL inline
-        result = subprocess.run(['python3', '-c', pymol_script], capture_output=True, text=True, cwd=str(OUTPUT_DIR))
-        if result.returncode != 0:
-            return jsonify({'success': False, 'error': f'PyMOL alignment failed: {result.stderr}'}), 500
-
-        if not aligned_lig.exists():
-            return jsonify({'success': False, 'error': 'Aligned ligand file was not produced'}), 500
-
-        # Read and return content
-        normalized_lines = []
-        with open(aligned_lig, 'r') as f:
-            for line in f:
-                if line.startswith('ATOM'):
-                    normalized_lines.append('HETATM' + line[6:])
-                else:
-                    normalized_lines.append(line)
-        content = ''.join(normalized_lines)
-        return jsonify({'success': True, 'exists': True, 'content': content})
-    except Exception as e:
-        logger.error(f"Error aligning ligands: {str(e)}")
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-@app.route('/viewer/<filename>')
-def viewer(filename):
-    """Serve NGL viewer page"""
-    # Check if the file exists, if not, try to generate it
-    file_path = OUTPUT_DIR / filename
-    if not file_path.exists():
-        # Try to generate the viewer PDB if it's the specific file we need
-        if filename == 'viewer_protein_with_ligand.pdb':
-            try:
-                # Call the get_viewer_pdb function to generate the file
-                result = get_viewer_pdb()
-                if result[1] == 200:  # Success
-                    pass  # File should now exist
-            except:
-                pass  # Continue anyway
-    
-    return f"""
-    <!DOCTYPE html>
-    <html>
-    <head>
-        <title>NGL Viewer - {filename}</title>
-        <script src="https://cdn.jsdelivr.net/npm/ngl@2.0.0-dev.37/dist/ngl.js"></script>
-        <style>
-            body {{ margin: 0; padding: 0; font-family: Arial, sans-serif; }}
-            #viewport {{ width: 100%; height: 100vh; }}
-            .header {{ background: #f8f9fa; padding: 10px; border-bottom: 1px solid #ddd; }}
-            .controls {{ padding: 10px; background: #f8f9fa; }}
-            .btn {{ padding: 8px 16px; margin: 5px; border: none; border-radius: 4px; cursor: pointer; }}
-            .btn-primary {{ background: #007bff; color: white; }}
-            .btn-secondary {{ background: #6c757d; color: white; }}
-        </style>
-    </head>
-    <body>
-        <div class="header">
-            <h3>🧬 3D Structure Viewer - {filename}</h3>
-        </div>
-        <div id="viewport"></div>
-        <div class="controls">
-            <button class="btn btn-primary" onclick="resetView()">Reset View</button>
-            <button class="btn btn-secondary" onclick="toggleRepresentation()">Toggle Style</button>
-            <button class="btn btn-secondary" onclick="toggleSpin()">Toggle Spin</button>
-        </div>
-        <script>
-            let stage;
-            let currentRepresentation = 'cartoon';
-            let isSpinning = false;
-
-            async function initViewer() {{
-                try {{
-                    // Check if file exists first
-                    const response = await fetch("/output/{filename}");
-                    if (!response.ok) {{
-                        throw new Error(`File not found: ${{response.status}} ${{response.statusText}}`);
-                    }}
-                    
-                    stage = new NGL.Stage("viewport", {{ backgroundColor: "white" }});
-                    
-                    const component = await stage.loadFile("/output/{filename}");
-                    
-                    // Add cartoon representation for protein
-                    component.addRepresentation("cartoon", {{
-                        sele: "protein",
-                        colorScheme: "chainname",
-                        opacity: 0.9
-                    }});
-
-                    // Add ball and stick for water molecules
-                    component.addRepresentation("ball+stick", {{
-                        sele: "water",
-                        color: "cyan",
-                        colorScheme: "uniform",
-                        radius: 0.1
-                    }});
-
-                    // Add ball and stick for ligands
-                    component.addRepresentation("ball+stick", {{
-                        sele: "hetero",
-                        color: "element",
-                        radius: 0.15
-                    }});
-
-                    stage.autoView();
-                }} catch (error) {{
-                    console.error('Error loading structure:', error);
-                    document.getElementById('viewport').innerHTML = 
-                        '<div style="padding: 50px; text-align: center; color: #dc3545;">' +
-                        '<h3>Error loading structure</h3><p>' + error.message + '</p>' +
-                        '<p>Make sure the file exists in the output directory.</p></div>';
-                }}
-            }}
-
-            function resetView() {{
-                if (stage) stage.autoView();
-            }}
-
-            function toggleRepresentation() {{
-                if (!stage) return;
-                const components = stage.compList;
-                if (components.length === 0) return;
-
-                const component = components[0];
-                component.removeAllRepresentations();
-
-                if (currentRepresentation === 'cartoon') {{
-                    component.addRepresentation("ball+stick", {{
-                        color: "element",
-                        radius: 0.15
-                    }});
-                    currentRepresentation = 'ball+stick';
-                }} else {{
-                    component.addRepresentation("cartoon", {{
-                        sele: "protein",
-                        colorScheme: "chainname",
-                        opacity: 0.9
-                    }});
-                    component.addRepresentation("ball+stick", {{
-                        sele: "water",
-                        color: "cyan",
-                        colorScheme: "uniform",
-                        radius: 0.1
-                    }});
-                    component.addRepresentation("ball+stick", {{
-                        sele: "hetero",
-                        color: "element",
-                        radius: 0.15
-                    }});
-                    currentRepresentation = 'cartoon';
-                }}
-            }}
-
-            function toggleSpin() {{
-                if (!stage) return;
-                isSpinning = !isSpinning;
-                stage.setSpin(isSpinning);
-            }}
-
-            // Initialize when page loads
-            document.addEventListener('DOMContentLoaded', initViewer);
-        </script>
-    </body>
-    </html>
-    """
-
-@app.route('/output/<path:filename>')
-def serve_output(filename):
-    """Serve output files"""
-    # Debug: print available files
-    print(f"Requested file: {filename}")
-    print(f"Full path: {OUTPUT_DIR / filename}")
-    print(f"File exists: {(OUTPUT_DIR / filename).exists()}")
-    print(f"Files in output dir: {list(OUTPUT_DIR.iterdir()) if OUTPUT_DIR.exists() else 'Directory not found'}")
-    
-    if not (OUTPUT_DIR / filename).exists():
-        abort(404)
-    
-    return send_from_directory(OUTPUT_DIR, filename)
-
-@app.route('/')
-def index():
-    """Serve the main HTML page"""
-    return render_template('index.html')
-
-@app.route('/<path:filename>')
-def serve_static(filename):
-    """Serve static files (CSS, JS, etc.)"""
-    return send_from_directory('../', filename)
-
-@app.route('/api/prepare-structure', methods=['POST'])
-def prepare_structure_endpoint():
-    """Prepare protein structure for AMBER"""
-    try:
-        data = request.get_json()
-        pdb_content = data.get('pdb_content', '')
-        options = data.get('options', {})
-        
-        if not pdb_content:
-            return jsonify({'error': 'No PDB content provided'}), 400
-        
-        # Prepare structure
-        result = prepare_structure(pdb_content, options)
-        
-        return jsonify({
-            'success': True,
-            'prepared_structure': result['prepared_structure'],
-            'original_atoms': result['original_atoms'],
-            'prepared_atoms': result['prepared_atoms'],
-            'removed_components': result['removed_components'],
-            'added_capping': result['added_capping'],
-            'preserved_ligands': result['preserved_ligands'],
-            'ligand_present': result.get('ligand_present', False),
-            'separate_ligands': result.get('separate_ligands', False),
-            'ligand_content': result.get('ligand_content', '')
-        })
-    
-    except Exception as e:
-        logger.error(f"Error preparing structure: {str(e)}")
-        return jsonify({'error': str(e)}), 500
-
-@app.route('/api/parse-structure', methods=['POST'])
-def parse_structure_endpoint():
-    """Parse structure information"""
-    try:
-        data = request.get_json()
-        pdb_content = data.get('pdb_content', '')
-        
-        if not pdb_content:
-            return jsonify({'error': 'No PDB content provided'}), 400
-        
-        # Parse structure
-        structure_info = parse_structure_info(pdb_content)
-        
-        return jsonify({
-            'success': True,
-            'structure_info': structure_info
-        })
-    
-    except Exception as e:
-        logger.error(f"Error parsing structure: {str(e)}")
-        return jsonify({'error': str(e)}), 500
-
-@app.route('/api/generate-ligand-ff', methods=['POST'])
-def generate_ligand_ff():
-    """Generate force field parameters for ligand"""
-    try:
-        data = request.get_json()
-        force_field = data.get('force_field', 'gaff2')
-        
-        # Determine the s parameter based on force field
-        s_param = 2 if force_field == 'gaff2' else 1
-        
-        # Paths for ligand files in output directory
-        ligand_pdb = OUTPUT_DIR / "4_ligands_corrected.pdb"
-        ligand_mol2 = OUTPUT_DIR / "4_ligands_corrected.mol2"
-        ligand_frcmod = OUTPUT_DIR / "4_ligands_corrected.frcmod"
-        
-        print(f"Working directory: {os.getcwd()}")
-        print(f"Output directory: {OUTPUT_DIR}")
-        print(f"Ligand PDB path: {ligand_pdb}")
-        print(f"Ligand MOL2 path: {ligand_mol2}")
-        print(f"Ligand FRCMOD path: {ligand_frcmod}")
-        
-        if not ligand_pdb.exists():
-            return jsonify({'error': 'Ligand PDB file not found. Please prepare structure with ligands first.'}), 400
-        
-        import re
-        
-        # Command 1: Calculate net charge using awk
-        print("Step 1: Calculating net charge from PDB file...")
-        # Look for charge in the last field (field 12) - pattern is letter+number+charge
-        awk_cmd = "awk '/^HETATM/ {if($NF ~ /[A-Z][0-9]-$/) charge--; if($NF ~ /[A-Z][0-9]\\+$/) charge++} END {print \"Net charge:\", charge+0}'"
-        cmd1 = f"{awk_cmd} {ligand_pdb}"
-        
-        try:
-            # Run awk command from the main directory, not output directory
-            result = subprocess.run(cmd1, shell=True, capture_output=True, text=True)
-            output = result.stdout.strip()
-            print(f"Awk output: '{output}'")
-            print(f"Awk stderr: '{result.stderr}'")
-            
-            # Extract net charge from awk output
-            net_charge_match = re.search(r'Net charge:\s*(-?\d+)', output)
-            if net_charge_match:
-                net_charge = int(net_charge_match.group(1))
-                print(f"Calculated net charge: {net_charge}")
-            else:
-                print("Could not extract net charge from awk output, using 0")
-                net_charge = 0
-        except Exception as e:
-            print(f"Error running awk command: {e}, using net charge 0")
-            net_charge = 0
-        
-        # Command 2: antechamber with calculated net charge
-        print(f"Step 2: Running antechamber with net charge {net_charge}...")
-        # Use relative paths and run in output directory
-        cmd2 = f"antechamber -i 4_ligands_corrected.pdb -fi pdb -o 4_ligands_corrected.mol2 -fo mol2 -c bcc -at {force_field} -nc {net_charge}"
-        print(f"Running command: {cmd2}")
-        result2 = subprocess.run(cmd2, shell=True, cwd=str(OUTPUT_DIR), capture_output=True, text=True)
-        
-        print(f"antechamber return code: {result2.returncode}")
-        print(f"antechamber stdout: {result2.stdout}")
-        print(f"antechamber stderr: {result2.stderr}")
-        
-        if result2.returncode != 0:
-            return jsonify({'error': f'antechamber failed with net charge {net_charge}. Error: {result2.stderr}'}), 500
-        
-        # Command 3: parmchk2
-        print("Step 3: Running parmchk2...")
-        # Use relative paths and run in output directory
-        cmd3 = f"parmchk2 -i 4_ligands_corrected.mol2 -f mol2 -o 4_ligands_corrected.frcmod -a Y -s {s_param}"
-        print(f"Running command: {cmd3}")
-        result3 = subprocess.run(cmd3, shell=True, cwd=str(OUTPUT_DIR), capture_output=True, text=True)
-        
-        print(f"parmchk2 return code: {result3.returncode}")
-        print(f"parmchk2 stdout: {result3.stdout}")
-        print(f"parmchk2 stderr: {result3.stderr}")
-        
-        if result3.returncode != 0:
-            return jsonify({'error': f'parmchk2 failed to generate force field parameters. Error: {result3.stderr}'}), 500
-        
-        # Check if files were generated successfully
-        print(f"After commands - MOL2 exists: {ligand_mol2.exists()}")
-        print(f"After commands - FRCMOD exists: {ligand_frcmod.exists()}")
-        print(f"Output directory contents: {list(OUTPUT_DIR.glob('*'))}")
-        
-        if not ligand_mol2.exists() or not ligand_frcmod.exists():
-            return jsonify({'error': 'Force field generation failed - output files not created'}), 500
-        
-        return jsonify({
-            'success': True,
-            'message': f'Ligand force field ({force_field}) generated successfully with net charge {net_charge}',
-            'net_charge': net_charge,
-            'files': {
-                'mol2': str(ligand_mol2),
-                'frcmod': str(ligand_frcmod)
-            }
-        })
-        
-    except Exception as e:
-        logger.error(f"Error generating ligand force field: {str(e)}")
-        return jsonify({'error': f'Internal server error: {str(e)}'}), 500
-
-@app.route('/api/calculate-net-charge', methods=['POST'])
-def calculate_net_charge():
-    """Calculate net charge of the system using tleap"""
-    try:
-        # Check if structure is prepared
-        tleap_ready_file = OUTPUT_DIR / "tleap_ready.pdb"
-        if not tleap_ready_file.exists():
-            return jsonify({'error': 'Structure not prepared. Please prepare structure first.'}), 400
-        
-        # Check if ligand is present
-        ligand_pdb = OUTPUT_DIR / "4_ligands_corrected.pdb"
-        ligand_present = ligand_pdb.exists()
-        
-        # Create dynamic tleap input file
-        tleap_input = OUTPUT_DIR / "calc_charge_on_system.in"
-        
-        # Get the selected force field from the request
-        data = request.get_json() if request.get_json() else {}
-        selected_force_field = data.get('force_field', 'ff14SB')
-        
-        with open(tleap_input, 'w') as f:
-            f.write(f"source leaprc.protein.{selected_force_field}\n")
-            f.write("source leaprc.gaff2\n\n")
-            
-            if ligand_present:
-                # Load ligand parameters and structure
-                f.write("loadamberparams 4_ligands_corrected.frcmod\n\n")
-                f.write("COB = loadmol2 4_ligands_corrected.mol2\n\n")
-            
-            f.write("x = loadpdb tleap_ready.pdb\n\n")
-            f.write("charge x\n\n")
-        
-        # Run tleap command
-        print("Running tleap to calculate system charge...")
-        # Find tleap executable dynamically
-        try:
-            # First try to find tleap in PATH
-            which_result = subprocess.run(['which', 'tleap'], capture_output=True, text=True)
-            if which_result.returncode == 0:
-                tleap_path = which_result.stdout.strip()
-            else:
-                # Fallback: try common conda environment paths
-                conda_env = os.environ.get('CONDA_DEFAULT_ENV', 'MD_pipeline')
-                conda_prefix = os.environ.get('CONDA_PREFIX', '')
-                if conda_prefix:
-                    tleap_path = os.path.join(conda_prefix, 'bin', 'tleap')
-                else:
-                    # Last resort: assume it's in PATH
-                    tleap_path = 'tleap'
-            
-            cmd = f"{tleap_path} -f calc_charge_on_system.in"
-            result = subprocess.run(cmd, shell=True, cwd=str(OUTPUT_DIR), capture_output=True, text=True)
-        except Exception as e:
-            # Fallback to simple tleap command
-            cmd = f"tleap -f calc_charge_on_system.in"
-            result = subprocess.run(cmd, shell=True, cwd=str(OUTPUT_DIR), capture_output=True, text=True)
-        
-        print(f"tleap return code: {result.returncode}")
-        print(f"tleap stdout: {result.stdout}")
-        print(f"tleap stderr: {result.stderr}")
-        
-        # Check if we got the charge information even if tleap had a non-zero exit code
-        # (tleap often returns non-zero when run non-interactively but still calculates charge)
-        if 'Total unperturbed charge' not in result.stdout and 'Total charge' not in result.stdout:
-            return jsonify({'error': f'tleap failed to calculate charge. Error: {result.stderr}'}), 500
-        
-        # Parse the output to find the net charge
-        output_lines = result.stdout.split('\n')
-        net_charge = None
-        
-        for line in output_lines:
-            if 'Total unperturbed charge' in line or 'Total charge' in line:
-                # Look for patterns like "Total charge: -3.0000" or "Total unperturbed charge: -3.0000"
-                import re
-                charge_match = re.search(r'charge[:\s]+(-?\d+\.?\d*)', line)
-                if charge_match:
-                    net_charge = float(charge_match.group(1))
-                    break
-        
-        if net_charge is None:
-            return jsonify({'error': 'Could not extract net charge from tleap output'}), 500
-        
-        # Suggest ion addition
-        if net_charge > 0:
-            suggestion = f"Add {int(net_charge)} Cl- ions to neutralize the system"
-            ion_type = "Cl-"
-            ion_count = int(net_charge)
-        elif net_charge < 0:
-            suggestion = f"Add {int(abs(net_charge))} Na+ ions to neutralize the system"
-            ion_type = "Na+"
-            ion_count = int(abs(net_charge))
-        else:
-            suggestion = "System is already neutral, no ions needed"
-            ion_type = "None"
-            ion_count = 0
-        
-        return jsonify({
-            'success': True,
-            'net_charge': net_charge,
-            'suggestion': suggestion,
-            'ion_type': ion_type,
-            'ion_count': ion_count,
-            'ligand_present': ligand_present
-        })
-        
-    except Exception as e:
-        logger.error(f"Error calculating net charge: {str(e)}")
-        return jsonify({'error': f'Internal server error: {str(e)}'}), 500
-
-@app.route('/api/generate-all-files', methods=['POST'])
-def generate_all_files():
-    """Generate all simulation input files based on UI parameters"""
-    try:
-        data = request.get_json()
-        
-        # Get simulation parameters from UI
-        cutoff_distance = data.get('cutoff_distance', 10.0)
-        temperature = data.get('temperature', 310.0)
-        pressure = data.get('pressure', 1.0)
-        
-        # Get step parameters
-        restrained_steps = data.get('restrained_steps', 10000)
-        restrained_force = data.get('restrained_force', 10.0)
-        min_steps = data.get('min_steps', 20000)
-        npt_heating_steps = data.get('npt_heating_steps', 50000)
-        npt_equilibration_steps = data.get('npt_equilibration_steps', 100000)
-        production_steps = data.get('production_steps', 1000000)
-        # Integration time step (ps)
-        dt = data.get('timestep', 0.002)
-        
-        # Get force field parameters
-        force_field = data.get('force_field', 'ff14SB')
-        water_model = data.get('water_model', 'TIP3P')
-        add_ions = data.get('add_ions', 'None')
-        distance = data.get('distance', 10.0)
-        
-        # Validation warnings
-        warnings = []
-        if restrained_steps < 5000:
-            warnings.append("Restrained minimization steps should be at least 5000")
-        if min_steps < 10000:
-            warnings.append("Minimization steps should be at least 10000")
-        
-        # Count total residues in tleap_ready.pdb
-        tleap_ready_file = OUTPUT_DIR / "tleap_ready.pdb"
-        if not tleap_ready_file.exists():
-            return jsonify({'error': 'tleap_ready.pdb not found. Please prepare structure first.'}), 400
-        
-        total_residues = count_residues_in_pdb(str(tleap_ready_file))
-        
-        # Generate min_restrained.in
-        generate_min_restrained_file(restrained_steps, restrained_force, total_residues, cutoff_distance)
-        
-        # Generate min.in
-        generate_min_file(min_steps, cutoff_distance)
-        
-        # Generate HeatNPT.in
-        generate_heat_npt_file(npt_heating_steps, temperature, pressure, cutoff_distance, dt)
-        
-        # Generate mdin_equi.in (NPT Equilibration)
-        generate_npt_equilibration_file(npt_equilibration_steps, temperature, pressure, cutoff_distance, dt)
-        
-        # Generate mdin_prod.in (Production)
-        generate_production_file(production_steps, temperature, pressure, cutoff_distance, dt)
-        
-        # Generate force field parameters
-        ff_files_generated = []
-        try:
-            generate_ff_parameters_file(force_field, water_model, add_ions, distance)
-            
-            # Find tleap executable
-            tleap_path = None
-            try:
-                result = subprocess.run(['which', 'tleap'], capture_output=True, text=True)
-                if result.returncode == 0:
-                    tleap_path = result.stdout.strip()
-            except:
-                pass
-            
-            if not tleap_path:
-                conda_prefix = os.environ.get('CONDA_PREFIX')
-                if conda_prefix:
-                    tleap_path = os.path.join(conda_prefix, 'bin', 'tleap')
-                else:
-                    tleap_path = '/home/hn533621/.conda/envs/MD_pipeline/bin/tleap'
-            
-            # Run tleap to generate force field parameters
-            cmd = f"{tleap_path} -f generate_ff_parameters.in"
-            result = subprocess.run(cmd, shell=True, cwd=str(OUTPUT_DIR), 
-                                  capture_output=True, text=True, timeout=300)
-            
-            if result.returncode != 0:
-                warnings.append(f"Force field generation failed: {result.stderr}")
-            else:
-                # Check if key output files were created
-                ff_output_files = ['protein.prmtop', 'protein.inpcrd', 'protein_solvated.pdb']
-                for ff_file in ff_output_files:
-                    if (OUTPUT_DIR / ff_file).exists():
-                        ff_files_generated.append(ff_file)
-                
-                if len(ff_files_generated) == 0:
-                    warnings.append("Force field parameter files were not generated")
-                
-        except Exception as ff_error:
-            warnings.append(f"Force field generation error: {str(ff_error)}")
-        
-        # Generate PBS submit script into output
-        pbs_generated = generate_submit_pbs_file()
-
-        all_files = [
-            'min_restrained.in',
-            'min.in', 
-            'HeatNPT.in',
-            'mdin_equi.in',
-            'mdin_prod.in'
-        ] + ff_files_generated
-
-        if pbs_generated:
-            all_files.append('submit_jobs.pbs')
-        
-        return jsonify({
-            'success': True,
-            'message': f'All simulation files generated successfully ({len(all_files)} files)',
-            'warnings': warnings,
-            'files_generated': all_files
-        })
-        
-    except Exception as e:
-        logger.error(f"Error generating simulation files: {str(e)}")
-        return jsonify({'error': f'Internal server error: {str(e)}'}), 500
-
-def count_residues_in_pdb(pdb_file):
-    """Count total number of residues in PDB file"""
-    try:
-        with open(pdb_file, 'r') as f:
-            lines = f.readlines()
-        
-        residues = set()
-        for line in lines:
-            if line.startswith(('ATOM', 'HETATM')):
-                # Extract residue number (columns 23-26)
-                residue_num = line[22:26].strip()
-                if residue_num:
-                    residues.add(residue_num)
-        
-        return len(residues)
-    except Exception as e:
-        logger.error(f"Error counting residues: {str(e)}")
-        return 607  # Default fallback
-
-def generate_min_restrained_file(steps, force_constant, total_residues, cutoff):
-    """Generate min_restrained.in file"""
-    content = f"""initial minimization solvent + ions
- &cntrl
-  imin   = 1,
-  maxcyc = {steps},
-  ncyc   = {steps // 2},
-  ntb    = 1,
-  ntr    = 1,
-  ntxo   = 1,	
-  cut    = {cutoff}
-/
-Restrain 
-{force_constant}
-RES 1 {total_residues}
-END
-END
-
-"""
-    
-    with open(OUTPUT_DIR / "min_restrained.in", 'w') as f:
-        f.write(content)
-
-def generate_min_file(steps, cutoff):
-    """Generate min.in file"""
-    content = f"""Minimization
-&cntrl
-imin=1,
-maxcyc={steps},
-ncyc={steps // 4},
-ntb=1,
-cut={cutoff},
-igb=0,
-ntr=0,
-/
-
-"""
-    
-    with open(OUTPUT_DIR / "min.in", 'w') as f:
-        f.write(content)
-
-def generate_heat_npt_file(steps, temperature, pressure, cutoff, dt=0.002):
-    """Generate HeatNPT.in file with temperature ramping"""
-    # Calculate step divisions: 20%, 20%, 20%, 40%
-    step1 = int(steps * 0.2)
-    step2 = int(steps * 0.2)
-    step3 = int(steps * 0.2)
-    step4 = int(steps * 0.4)
-    
-    # Calculate temperature values: 3%, 66%, 100%
-    temp1 = temperature * 0.03
-    temp2 = temperature * 0.66
-    temp3 = temperature
-    temp4 = temperature
-    
-    content = f"""Heat
- &cntrl
-  imin = 0, irest = 0, ntx = 1,
-  ntb = 2, pres0 = {pressure}, ntp = 1,
-  taup = 2.0,
-  cut = {cutoff}, ntr = 0,
-  ntc = 2, ntf = 2,
-  tempi = 0, temp0 = {temperature},
-  ntt = 3, gamma_ln = 1.0,
-  nstlim = {steps}, dt = {dt},
-  ntpr = 2000, ntwx = 2000, ntwr = 2000
- /
-&wt type='TEMP0', istep1=0, istep2={step1}, value1=0.0, value2={temp1} /
-&wt type='TEMP0', istep1={step1+1}, istep2={step1+step2}, value1={temp1}, value2={temp2} /
-&wt type='TEMP0', istep1={step1+step2+1}, istep2={step1+step2+step3}, value1={temp2}, value2={temp3} /
-&wt type='TEMP0', istep1={step1+step2+step3+1}, istep2={steps}, value1={temp3}, value2={temp4} /
-&wt type='END' /
-
-"""
-    
-    with open(OUTPUT_DIR / "HeatNPT.in", 'w') as f:
-        f.write(content)
-
-def generate_npt_equilibration_file(steps, temperature, pressure, cutoff, dt=0.002):
-    """Generate mdin_equi.in file for NPT equilibration"""
-    content = f"""NPT Equilibration
-&cntrl
-  imin=0,
-  ntx=1,
-  irest=0,
-  pres0={pressure},
-  taup=1.0,
-  temp0={temperature},
-  tempi={temperature},
-  nstlim={steps},
-  dt={dt},
-  ntf=2,
-  ntc=2,
-  ntpr=500,
-  ntwx=500,
-  ntwr=500,
-  cut={cutoff},
-  ntb=2,
-  ntp=1,
-  ntt=3,
-  gamma_ln=3.0,
-  ig=-1,
-  iwrap=1,
-  ntr=0,
-/
-
-"""
-    
-    with open(OUTPUT_DIR / "mdin_equi.in", 'w') as f:
-        f.write(content)
-
-def generate_production_file(steps, temperature, pressure, cutoff, dt=0.002):
-    """Generate mdin_prod.in file for production run"""
-    content = f"""Production Run
-&cntrl
-  imin=0,
-  ntx=1,
-  irest=0,
-  pres0={pressure},
-  taup=1.0,
-  temp0={temperature},
-  tempi={temperature},
-  nstlim={steps},
-  dt={dt},
-  ntf=2,
-  ntc=2,
-  ntpr=1000,
-  ntwx=1000,
-  ntwr=1000,
-  cut={cutoff},
-  ntb=2,
-  ntp=1,
-  ntt=3,
-  gamma_ln=3.0,
-  ig=-1,
-  iwrap=1,
-  ntr=0,
-/
-
-"""
-    
-    with open(OUTPUT_DIR / "mdin_prod.in", 'w') as f:
-        f.write(content)
-
-def generate_submit_pbs_file():
-    """Copy submit_jobs.pbs template into output folder"""
-    try:
-        templates_dir = Path("templates")
-        template_path = templates_dir / "submit_jobs.pbs"
-        if not template_path.exists():
-            logger.warning("submit_jobs.pbs template not found; skipping PBS generation")
-            return False
-        with open(template_path, 'r') as tf:
-            content = tf.read()
-        with open(OUTPUT_DIR / "submit_jobs.pbs", 'w') as outf:
-            outf.write(content)
-        return True
-    except Exception as e:
-        logger.error(f"Error generating submit_jobs.pbs: {e}")
-        return False
-
-@app.route('/api/health', methods=['GET'])
-def health_check():
-    """Health check endpoint"""
-    return jsonify({'status': 'healthy', 'message': 'MD Simulation Pipeline API is running'})
-
-@app.route('/api/clean-output', methods=['POST'])
-def clean_output():
-    """Clean output folder endpoint"""
-    try:
-        print("DEBUG: clean-output endpoint called")
-        if clean_and_create_output_folder():
-            return jsonify({'success': True, 'message': 'Output folder cleaned successfully'})
-        else:
-            return jsonify({'success': False, 'error': 'Failed to clean output folder'}), 500
-    except Exception as e:
-        print(f"DEBUG: Error in clean-output: {str(e)}")
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-@app.route('/api/download-output-zip', methods=['GET'])
-def download_output_zip():
-    """Create a ZIP of the output folder and return it for download"""
-    try:
-        if not OUTPUT_DIR.exists():
-            return jsonify({'error': 'Output directory not found'}), 404
-
-        import tempfile
-        import shutil
-
-        # Create a temporary zip file
-        tmp_dir = tempfile.mkdtemp()
-        zip_base = os.path.join(tmp_dir, 'output')
-        zip_path = shutil.make_archive(zip_base, 'zip', root_dir=str(OUTPUT_DIR))
-
-        # Send file for download
-        return send_file(zip_path, as_attachment=True, download_name='output.zip')
-    except Exception as e:
-        logger.error(f"Error creating output ZIP: {str(e)}")
-        return jsonify({'error': f'Failed to create ZIP: {str(e)}'}), 500
-
-@app.route('/api/get-generated-files', methods=['GET'])
-def get_generated_files():
-    """Return contents of known generated input files for preview"""
-    try:
-        files_to_read = [
-            'min_restrained.in',
-            'min.in',
-            'HeatNPT.in',
-            'mdin_equi.in',
-            'mdin_prod.in'
-        ]
-        # Note: Force field parameter files (protein.prmtop, protein.inpcrd, protein_solvated.pdb) 
-        # are excluded from preview as they are binary/large files
-        result = {}
-        for name in files_to_read:
-            path = OUTPUT_DIR / name
-            if path.exists():
-                try:
-                    with open(path, 'r') as f:
-                        result[name] = f.read()
-                except Exception as fe:
-                    result[name] = f"<error reading file: {fe}>"
-            else:
-                result[name] = "<file not found>"
-        return jsonify({'success': True, 'files': result})
-    except Exception as e:
-        logger.error(f"Error reading generated files: {str(e)}")
-        return jsonify({'error': f'Failed to read files: {str(e)}'}), 500
-
-def get_ligand_residue_name():
-    """Extract ligand residue name from tleap_ready.pdb"""
-    try:
-        with open(OUTPUT_DIR / "tleap_ready.pdb", 'r') as f:
-            for line in f:
-                if line.startswith('HETATM'):
-                    # Extract residue name (columns 18-20)
-                    residue_name = line[17:20].strip()
-                    if residue_name and residue_name not in ['HOH', 'WAT', 'TIP', 'SPC']:  # Exclude water
-                        return residue_name
-        return "LIG"  # Default fallback
-    except:
-        return "LIG"  # Default fallback
-
-def generate_ff_parameters_file(force_field, water_model, add_ions, distance):
-    """Generate the final force field parameters file with dynamic values"""
-    # Debug logging
-    print(f"DEBUG: force_field={force_field}, water_model={water_model}, add_ions={add_ions}, distance={distance}")
-    
-    # Determine if ligand is present
-    ligand_present = (OUTPUT_DIR / "4_ligands_corrected.mol2").exists()
-    
-    # Get dynamic ligand residue name
-    ligand_name = get_ligand_residue_name()
-    
-    # Build the content dynamically
-    content = f"source leaprc.protein.{force_field}\n"
-    
-    # Add water model source
-    print(f"DEBUG: water_model={water_model}")
-    if water_model.lower() == "tip3p":
-        content += "source leaprc.water.tip3p\n"
-    elif water_model == "spce":
-        content += "source leaprc.water.spce\n"
-    
-    # Add ligand-related commands only if ligand is present
-    if ligand_present:
-        content += "source leaprc.gaff2\n\n"
-        content += "loadamberparams 4_ligands_corrected.frcmod\n\n"
-        content += f"{ligand_name} = loadmol2 4_ligands_corrected.mol2\n\n"
-    else:
-        content += "\n"
-    
-    content += "x = loadpdb tleap_ready.pdb\n\n"
-    content += "charge x\n\n"
-    
-    # Add ions based on selection
-    if add_ions == "Na+":
-        content += "addions x Na+ 0.0\n\n"
-    elif add_ions == "Cl-":
-        content += "addions x Cl- 0.0\n\n"
-    # If "None", skip adding ions
-    
-    # Add solvation with selected water model and distance
-    if water_model.lower() == "tip3p":
-        content += f"solvateBox x TIP3PBOX {distance}\n\n"
-    elif water_model.lower() == "spce":
-        content += f"solvateBox x SPCBOX {distance}\n\n"
-    
-    content += "saveamberparm x protein.prmtop protein.inpcrd\n\n"
-    content += "savepdb x protein_solvated.pdb\n\n"
-    content += "quit\n"
-    
-    # Debug: print the generated content
-    print("DEBUG: Generated content:")
-    print(content)
-    
-    # Write the file
-    with open(OUTPUT_DIR / "generate_ff_parameters.in", 'w') as f:
-        f.write(content)
-
-@app.route('/api/generate-ff-parameters', methods=['POST'])
-def generate_ff_parameters():
-    """Generate final force field parameters using tleap"""
-    try:
-        data = request.get_json()
-        force_field = data.get('force_field', 'ff14SB')
-        water_model = data.get('water_model', 'TIP3P')
-        add_ions = data.get('add_ions', 'None')
-        distance = data.get('distance', 10.0)
-        
-        # Generate the dynamic input file
-        generate_ff_parameters_file(force_field, water_model, add_ions, distance)
-        
-        # Find tleap executable
-        tleap_path = None
-        try:
-            result = subprocess.run(['which', 'tleap'], capture_output=True, text=True)
-            if result.returncode == 0:
-                tleap_path = result.stdout.strip()
-        except:
-            pass
-        
-        if not tleap_path:
-            conda_prefix = os.environ.get('CONDA_PREFIX')
-            if conda_prefix:
-                tleap_path = os.path.join(conda_prefix, 'bin', 'tleap')
-            else:
-                tleap_path = '/home/hn533621/.conda/envs/MD_pipeline/bin/tleap'
-        
-        # Run tleap
-        cmd = f"{tleap_path} -f generate_ff_parameters.in"
-        result = subprocess.run(cmd, shell=True, cwd=str(OUTPUT_DIR), 
-                              capture_output=True, text=True, timeout=300)
-        
-        if result.returncode != 0:
-            logger.error(f"tleap failed: {result.stderr}")
-            return jsonify({
-                'success': False, 
-                'error': f'tleap failed: {result.stderr}'
-            }), 500
-        
-        # Check if key output files were created
-        output_files = ['protein.prmtop', 'protein.inpcrd', 'protein_solvated.pdb']
-        missing_files = [f for f in output_files if not (OUTPUT_DIR / f).exists()]
-        
-        if missing_files:
-            return jsonify({
-                'success': False,
-                'error': f'Missing output files: {", ".join(missing_files)}'
-            }), 500
-        
-        return jsonify({
-            'success': True,
-            'message': 'Force field parameters generated successfully',
-            'files_generated': output_files
-        })
-        
-    except subprocess.TimeoutExpired:
-        return jsonify({
-            'success': False,
-            'error': 'tleap command timed out after 5 minutes'
-        }), 500
-    except Exception as e:
-        logger.error(f"Error generating FF parameters: {str(e)}")
-        return jsonify({
-            'success': False,
-            'error': f'Failed to generate force field parameters: {str(e)}'
-        }), 500
-
-if __name__ == '__main__':
-    print("🧬 MD Simulation Pipeline")
-    print("=========================")
-    print("🌐 Starting Flask server...")
-    print("📡 Backend API: http://localhost:5000")
-    print("🔗 Web Interface: http://localhost:5000")
-    print("")
-    print("Press Ctrl+C to stop the server")
-    print("")
-    
-    # Clean and create fresh output folder on startup
-    print("🧹 Cleaning output folder...")
-    clean_and_create_output_folder()
-    print("✅ Output folder ready!")
-    print("")
-    
-    app.run(debug=False, host='0.0.0.0', port=5000)

start_web_server.py

@@ -1,20 +1,10 @@
 #!/usr/bin/env python3
 """
-AmberFlow - Hugging Face Spaces Entry Point
-This file serves as the entry point for Hugging Face Spaces deployment.
-It imports and runs the existing Flask application from python/app.py
+AmberFlow - Entry point when running from project root.
+Uses the amberflow package. For installed package: use `amberflow` or `python -m amberflow`.
 """
 
-import os
-import sys
-import subprocess
-
-# Add the python directory to the path so we can import the Flask app
-sys.path.append(os.path.join(os.path.dirname(__file__), 'python'))
-
-# Import the Flask app from the existing python/app.py
-from python.app import app
+from amberflow.app import app
 
 if __name__ == "__main__":
-    # Run the Flask app
-    app.run(debug=False, host='0.0.0.0', port=7860)
+    app.run(debug=False, host="0.0.0.0", port=7860)