Deploy AmberFlow to Hugging Face Spaces

Dockerfile

@@ -0,0 +1,56 @@
+FROM python:3.9-slim
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    wget \
+    curl \
+    build-essential \
+    gcc \
+    g++ \
+    make \
+    libffi-dev \
+    libssl-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install conda
+RUN wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh && \
+    bash Miniconda3-latest-Linux-x86_64.sh -b -p /opt/conda && \
+    rm Miniconda3-latest-Linux-x86_64.sh
+
+ENV PATH="/opt/conda/bin:${PATH}"
+
+# Install AMBER tools and PyMOL via conda
+RUN conda install -c conda-forge -c bioconda \
+    ambertools \
+    pymol-open-source \
+    -y
+
+# Install Python packages via pip
+RUN pip install --no-cache-dir \
+    flask==2.3.3 \
+    flask-cors==4.0.0 \
+    biopython==1.81 \
+    numpy==1.24.3 \
+    pandas==2.0.3 \
+    matplotlib==3.7.2 \
+    seaborn==0.12.2 \
+    mdanalysis==2.5.0 \
+    gunicorn==21.2.0 \
+    requests==2.31.0 \
+    rdkit==2023.3.1 \
+    scipy==1.11.1
+
+# Set working directory
+WORKDIR /AmberFlow
+
+# Copy the entire project
+COPY . .
+
+# Make sure the python directory is in the Python path
+ENV PYTHONPATH="${PYTHONPATH}:/AmberFlow/python"
+
+# Expose the port
+EXPOSE 7860
+
+# Run the application
+CMD ["python", "start_web_server.py"]

README.md

@@ -1,12 +1,126 @@
+<!--
 ---
-title: AmberFlow
-emoji: 🌖
-colorFrom: indigo
+title: AmberFlow - MD Simulation Pipeline
+emoji: 🧬
+colorFrom: blue
 colorTo: purple
 sdk: docker
 pinned: false
 license: mit
-short_description: AMBER input simulation files generator for proteins
+app_port: 7860
 ---
+-->
+
+# AmberFlow - Molecular Dynamics Simulation Pipeline
+
+🧬 **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.
+
+## Features
+
+### 🔬 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
+
+## 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
+```
+AmberFlow/
+├── app.py                 # Hugging Face Spaces entry point
+├── requirements.txt       # Python dependencies
+├── python/
+│   ├── app.py            # Main Flask application
+│   ├── structure_preparation.py
+│   └── requirements.txt
+├── html/
+│   └── index.html        # Web interface
+├── css/
+│   └── styles.css        # Styling
+├── js/
+│   └── script.js         # Frontend logic
+├── templates/            # AMBER input file templates
+└── add_caps.py          # Capping group addition script
+```
+
+## Citation
+
+If you use AmberFlow in your research, please cite:
+
+```bibtex
+@software{Amberflow2025,
+  title={AmberFlow: Molecular Dynamics Simulation Pipeline},
+  author={Hemant Nagar},
+  year={2025},
+  url={https://huggingface.co/spaces/hemantn/AmberFlow}
+}
+```
+
+## Acknowledgments
+
+- **Mohd Ibrahim** (Technical University of Munich) for the protein capping functionality (`add_caps.py`)
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Contact
+
+- **Author**: Hemant Nagar
+- **Email**: hn533621@ohio.edu
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

add_caps.py

@@ -0,0 +1,176 @@
+# Written by Mohd Ibrahim
+# Technical University of Munich
+# Email: ibrahim.mohd@tum.de
+
+import numpy as np
+import MDAnalysis as mda
+import argparse
+import warnings
+warnings.filterwarnings("ignore")
+
+np.random.seed(42)  
+
+parser = argparse.ArgumentParser(
+    description="Add capping groups ACE and NME to protein termini. "
+                "Remove hydrogens before using this script")
+parser.add_argument('-i', dest='in_file', type=str,
+                    default='protein_noh.pdb', help='pdb file')
+parser.add_argument('-o', dest='out_file', type=str,
+                    default='protein_noh_cap.pdb', help='output file')
+
+args = parser.parse_args()
+in_file = args.in_file
+out_file = args.out_file
+
+
+def create_universe(n_atoms, name, resname, positions, resids, segid):
+    u_new = mda.Universe.empty(
+        n_atoms=n_atoms,
+        n_residues=n_atoms,
+        atom_resindex=np.arange(n_atoms),
+        residue_segindex=np.arange(n_atoms),
+        n_segments=n_atoms,
+        trajectory=True
+    )
+    u_new.add_TopologyAttr('name', name)
+    u_new.add_TopologyAttr('resid', resids)
+    u_new.add_TopologyAttr('resname', resname)
+    u_new.atoms.positions = positions
+    u_new.add_TopologyAttr('segid', n_atoms * [segid])
+    u_new.add_TopologyAttr('chainID', n_atoms * [segid])
+    return u_new
+
+
+def get_nme_pos(end_residue):
+    if "OXT" in end_residue.names:
+        index = np.where(end_residue.names == "OXT")[0][0]
+        N_position = end_residue.positions[index]
+        index_c = np.where(end_residue.names == "C")[0][0]
+        carbon_position = end_residue.positions[index_c]
+        vector = N_position - carbon_position
+        vector /= np.sqrt(sum(vector**2))
+        C_position = N_position + vector * 1.36
+        return N_position, C_position
+    else:
+        index_o = np.where(end_residue.names == "O")[0][0]
+        index_ca = np.where(end_residue.names == "CA")[0][0]
+        mid_point = (end_residue.positions[index_o] +
+                     end_residue.positions[index_ca]) / 2
+        index_c = np.where(end_residue.names == "C")[0][0]
+        vector = end_residue.positions[index_c] - mid_point
+        vector /= np.sqrt(sum(vector**2))
+        N_position = end_residue.positions[index_c] + 1.36 * vector
+        C_position = N_position + 1.36 * vector
+        return N_position, C_position
+
+
+def get_ace_pos(end_residue):
+    index_ca = np.where(end_residue.names == "CA")[0][0]
+    index_n = np.where(end_residue.names == "N")[0][0]
+    vector = end_residue.positions[index_n] - end_residue.positions[index_ca]
+    vector /= np.sqrt(sum(vector**2))
+    C1_position = end_residue.positions[index_n] + 1.36 * vector
+
+    xa, ya, za = end_residue.positions[index_ca]
+    xg, yg, zg = C1_position
+
+    orientation = np.array([2 * np.random.rand() - 1,
+                            2 * np.random.rand() - 1,
+                            2 * np.random.rand() - 1])
+    nx, ny, nz = orientation / np.sqrt(sum(orientation**2))
+
+    x1 = xg - (xa - xg) / 2 + np.sqrt(3) * (ny * (za - zg) - nz * (ya - yg)) / 2
+    y1 = yg - (ya - yg) / 2 + np.sqrt(3) * (nz * (xa - xg) - nx * (za - zg)) / 2
+    z1 = zg - (za - zg) / 2 + np.sqrt(3) * (nx * (ya - yg) - ny * (xa - xg)) / 2
+
+    x2 = xg - (xa - xg) / 2 - np.sqrt(3) * (ny * (za - zg) - nz * (ya - yg)) / 2
+    y2 = yg - (ya - yg) / 2 - np.sqrt(3) * (nz * (xa - xg) - nx * (za - zg)) / 2
+    z2 = zg - (za - zg) / 2 - np.sqrt(3) * (nx * (ya - yg) - ny * (xa - xg)) / 2
+
+    C2_position = np.array([x1, y1, z1])
+    O_position = np.array([x2, y2, z2])
+
+    vector = C2_position - C1_position
+    vector /= np.sqrt(sum(vector**2))
+    C2_position = C1_position + 1.36 * vector
+
+    vector = O_position - C1_position
+    vector /= np.sqrt(sum(vector**2))
+    O_position = C1_position + 1.36 * vector
+
+    return C1_position, C2_position, O_position
+
+
+# ----------- Main processing -----------
+u = mda.Universe(in_file)
+res_start = 0
+segment_universes = []
+
+for seg in u.segments:
+    chain = u.select_atoms(f"segid {seg.segid}")
+
+    # ACE
+    resid_c = chain.residues.resids[0]
+    end_residue = u.select_atoms(f"segid {seg.segid} and resid {resid_c}")
+    c1_pos, c2_pos, o_pos = get_ace_pos(end_residue)
+
+    # keep original mapping (C, CH3, O)
+    ace_names = ["C", "CH3", "O"]
+    ace_positions = [c1_pos, c2_pos, o_pos]
+    resid = chain.residues.resids[0]
+    ace_universe = create_universe(
+        n_atoms=len(ace_positions),
+        name=ace_names,
+        resname=len(ace_names) * ["ACE"],
+        positions=ace_positions,
+        resids=resid * np.ones(len(ace_names)),
+        segid=chain.segids[0]
+    )
+
+    # >>> Reorder rows only: CH3, C, O <<<
+    ace_universe = mda.Merge(
+        ace_universe.atoms.select_atoms("name CH3"),
+        ace_universe.atoms.select_atoms("name C"),
+        ace_universe.atoms.select_atoms("name O")
+    )
+
+    # NME
+    resid_c = chain.residues.resids[-1]
+    end_residue = u.select_atoms(f"segid {seg.segid} and resid {resid_c}")
+    nme_positions = get_nme_pos(end_residue)
+    nme_names = ["N", "C"]
+    resid = chain.residues.resids[-1] + 2
+    nme_universe = create_universe(
+        n_atoms=len(nme_names),
+        name=nme_names,
+        resname=len(nme_names) * ["NME"],
+        positions=nme_positions,
+        resids=resid * np.ones(len(nme_names)),
+        segid=chain.segids[0]
+    )
+
+    # Remove OXT if present
+    if "OXT" in end_residue.names:
+        index = np.where(end_residue.names == "OXT")[0][0]
+        OXT = end_residue[index]
+        Chain = u.select_atoms(f"segid {seg.segid} and not index {OXT.index}")
+    else:
+        Chain = u.select_atoms(f"segid {seg.segid}")
+
+    # Merge ACE, protein, NME
+    u_all = mda.Merge(ace_universe.atoms, Chain, nme_universe.atoms)
+
+    # Renumber residues
+    resids_ace = [res_start + 1] * 3
+    resids_pro = np.arange(resids_ace[0] + 1,
+                           Chain.residues.n_residues + resids_ace[0] + 1)
+    resids_nme = [resids_pro[-1] + 1] * 2
+    u_all.atoms.residues.resids = np.concatenate(
+        [resids_ace, resids_pro, resids_nme]
+    )
+    res_start = u_all.atoms.residues.resids[-1]
+    segment_universes.append(u_all)
+
+# Join and write output
+all_uni = mda.Merge(*(seg.atoms for seg in segment_universes))
+all_uni.atoms.write(out_file)

css/styles.css

@@ -0,0 +1,1113 @@
+/* Reset and Base Styles */
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    line-height: 1.6;
+    color: #333;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    min-height: 100vh;
+}
+
+.container {
+    max-width: 1400px;
+    margin: 0 auto;
+    background: white;
+    min-height: 100vh;
+    box-shadow: 0 0 30px rgba(0, 0, 0, 0.1);
+}
+
+/* Header Styles */
+.header {
+    background: linear-gradient(135deg, #2c3e50 0%, #3498db 100%);
+    color: white;
+    padding: 2rem 0;
+    text-align: center;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+}
+
+.header-content h1 {
+    font-size: 2.5rem;
+    margin-bottom: 0.5rem;
+    font-weight: 300;
+}
+
+.header-content p {
+    font-size: 1.1rem;
+    opacity: 0.9;
+}
+
+.header i {
+    margin-right: 0.5rem;
+    color: #3498db;
+}
+
+/* Tab Navigation */
+.tab-navigation {
+    display: flex;
+    background: #34495e;
+    border-bottom: 3px solid #3498db;
+    overflow-x: auto;
+}
+
+/* Step Navigation Controls */
+.step-navigation {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    background: #ffffff;
+    padding: 20px 30px;
+    border-top: 1px solid #dee2e6;
+    box-shadow: 0 -2px 8px rgba(0,0,0,0.1);
+    position: sticky;
+    bottom: 0;
+    z-index: 100;
+}
+
+/* Checkbox with Button Layout */
+.checkbox-with-button {
+    display: flex;
+    align-items: center;
+    gap: 15px;
+    margin-bottom: 10px;
+}
+
+.checkbox-with-button .checkbox-container {
+    margin-bottom: 0;
+    flex: 1;
+}
+
+.btn-sm {
+    padding: 6px 12px;
+    font-size: 12px;
+    border-radius: 4px;
+}
+
+.btn-outline-primary {
+    color: #007bff;
+    border: 1px solid #007bff;
+    background: transparent;
+}
+
+.btn-outline-primary:hover:not(:disabled) {
+    color: white;
+    background: #007bff;
+    border-color: #007bff;
+}
+
+.btn-outline-primary:disabled {
+    color: #6c757d;
+    border-color: #6c757d;
+    background: transparent;
+    cursor: not-allowed;
+}
+
+.nav-btn {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 10px 20px;
+    border: 2px solid #007bff;
+    background: #007bff;
+    color: white;
+    border-radius: 25px;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    font-size: 14px;
+}
+
+.nav-btn:hover:not(:disabled) {
+    background: #0056b3;
+    border-color: #0056b3;
+    transform: translateY(-2px);
+    box-shadow: 0 4px 8px rgba(0,123,255,0.3);
+}
+
+.nav-btn:disabled {
+    background: #6c757d;
+    border-color: #6c757d;
+    cursor: not-allowed;
+    opacity: 0.6;
+}
+
+.step-indicator {
+    display: flex;
+    align-items: center;
+    gap: 5px;
+    font-weight: 600;
+    color: #495057;
+    font-size: 16px;
+}
+
+.step-indicator span {
+    background: #e9ecef;
+    padding: 8px 12px;
+    border-radius: 20px;
+    min-width: 30px;
+    text-align: center;
+}
+
+.step-indicator #current-step {
+    background: #007bff;
+    color: white;
+}
+
+.tab-button {
+    flex: 1;
+    background: none;
+    border: none;
+    color: white;
+    padding: 1rem 1.5rem;
+    cursor: pointer;
+    font-size: 1rem;
+    font-weight: 500;
+    transition: all 0.3s ease;
+    border-bottom: 3px solid transparent;
+    min-width: 200px;
+}
+
+.tab-button:hover {
+    background: rgba(255, 255, 255, 0.1);
+    transform: translateY(-2px);
+}
+
+.tab-button.active {
+    background: #3498db;
+    border-bottom-color: #e74c3c;
+    transform: translateY(-2px);
+}
+
+.tab-button i {
+    margin-right: 0.5rem;
+    font-size: 1.1rem;
+}
+
+/* Main Content */
+.main-content {
+    padding: 2rem;
+    min-height: 600px;
+}
+
+.tab-content {
+    display: none;
+    animation: fadeIn 0.5s ease-in-out;
+}
+
+.tab-content.active {
+    display: block;
+}
+
+@keyframes fadeIn {
+    from { opacity: 0; transform: translateY(20px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+/* Card Styles */
+.card {
+    background: white;
+    border-radius: 12px;
+    box-shadow: 0 8px 25px rgba(0, 0, 0, 0.1);
+    padding: 2rem;
+    margin-bottom: 2rem;
+    border: 1px solid #e1e8ed;
+}
+
+.card h2 {
+    color: #2c3e50;
+    margin-bottom: 1.5rem;
+    font-size: 1.8rem;
+    font-weight: 600;
+    border-bottom: 2px solid #3498db;
+    padding-bottom: 0.5rem;
+}
+
+.card h2 i {
+    margin-right: 0.5rem;
+    color: #3498db;
+}
+
+/* Protein Loading Styles */
+.input-methods {
+    display: grid;
+    grid-template-columns: 1fr auto 1fr;
+    gap: 2rem;
+    align-items: center;
+    margin-bottom: 2rem;
+}
+
+.method-option {
+    background: #f8f9fa;
+    padding: 1.5rem;
+    border-radius: 8px;
+    border: 2px dashed #dee2e6;
+    transition: all 0.3s ease;
+}
+
+.method-option:hover {
+    border-color: #3498db;
+    background: #f0f8ff;
+}
+
+.method-option h3 {
+    color: #2c3e50;
+    margin-bottom: 1rem;
+    font-size: 1.2rem;
+}
+
+.method-option h3 i {
+    margin-right: 0.5rem;
+    color: #3498db;
+}
+
+.divider {
+    text-align: center;
+    font-weight: bold;
+    color: #7f8c8d;
+    font-size: 1.1rem;
+}
+
+.divider::before,
+.divider::after {
+    content: '';
+    display: inline-block;
+    width: 50px;
+    height: 2px;
+    background: #bdc3c7;
+    vertical-align: middle;
+    margin: 0 1rem;
+}
+
+/* File Upload Area */
+.file-upload-area {
+    border: 2px dashed #3498db;
+    border-radius: 8px;
+    padding: 2rem;
+    text-align: center;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    background: #f8f9fa;
+}
+
+.file-upload-area:hover {
+    background: #e3f2fd;
+    border-color: #2980b9;
+}
+
+.file-upload-area i {
+    font-size: 3rem;
+    color: #3498db;
+    margin-bottom: 1rem;
+    display: block;
+}
+
+.file-upload-area p {
+    margin-bottom: 1rem;
+    color: #7f8c8d;
+}
+
+.file-info {
+    background: #d4edda;
+    border: 1px solid #c3e6cb;
+    border-radius: 4px;
+    padding: 1rem;
+    margin-top: 1rem;
+}
+
+.file-info p {
+    margin: 0.25rem 0;
+    color: #155724;
+}
+
+/* PDB Fetch */
+.pdb-fetch {
+    margin-top: 1rem;
+}
+
+.input-group {
+    display: flex;
+    gap: 1rem;
+    align-items: end;
+}
+
+.input-group label {
+    font-weight: 600;
+    color: #2c3e50;
+    margin-bottom: 0.5rem;
+    display: block;
+}
+
+.input-group input {
+    flex: 1;
+    padding: 0.75rem;
+    border: 2px solid #dee2e6;
+    border-radius: 4px;
+    font-size: 1rem;
+    transition: border-color 0.3s ease;
+}
+
+.input-group input:focus {
+    outline: none;
+    border-color: #3498db;
+    box-shadow: 0 0 0 3px rgba(52, 152, 219, 0.1);
+}
+
+/* Status Messages */
+.status-message {
+    margin-top: 1rem;
+    padding: 0.75rem;
+    border-radius: 4px;
+    font-weight: 500;
+}
+
+.status-message.success {
+    background: #d4edda;
+    color: #155724;
+    border: 1px solid #c3e6cb;
+}
+
+.status-message.error {
+    background: #f8d7da;
+    color: #721c24;
+    border: 1px solid #f5c6cb;
+}
+
+.status-message.info {
+    background: #d1ecf1;
+    color: #0c5460;
+    border: 1px solid #bee5eb;
+}
+
+/* Protein Preview */
+.protein-preview {
+    margin-top: 2rem;
+    background: #f8f9fa;
+    border-radius: 8px;
+    padding: 1.5rem;
+    border: 1px solid #dee2e6;
+}
+
+.preview-content {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 2rem;
+    margin-top: 1rem;
+}
+
+.protein-info p {
+    margin: 0.5rem 0;
+    font-size: 1rem;
+}
+
+.protein-visualization {
+    background: white;
+    border-radius: 4px;
+    padding: 1rem;
+    border: 1px solid #dee2e6;
+    min-height: 300px;
+    position: relative;
+}
+
+/* Ensure NGL viewer controls overlay within both original and prepared viewers */
+.molecule-viewer {
+    position: relative;
+}
+
+#ngl-viewer {
+    border-radius: 4px;
+    background: #f8f9fa;
+    border: 1px solid #dee2e6;
+}
+
+.viewer-controls {
+    position: absolute;
+    top: 10px;
+    right: 10px;
+    display: flex;
+    gap: 0.5rem;
+    z-index: 10;
+}
+
+.viewer-controls .btn {
+    padding: 0.25rem 0.5rem;
+    font-size: 0.8rem;
+    border-radius: 3px;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+
+.viewer-controls .btn:hover {
+    transform: translateY(-1px);
+    box-shadow: 0 4px 8px rgba(0,0,0,0.15);
+}
+
+/* Simulation Parameters */
+.params-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+    gap: 2rem;
+}
+
+.param-section {
+    background: #f8f9fa;
+    padding: 1.5rem;
+    border-radius: 8px;
+    border: 1px solid #dee2e6;
+}
+
+.param-section h3 {
+    color: #2c3e50;
+    margin-bottom: 1rem;
+    font-size: 1.2rem;
+    border-bottom: 1px solid #bdc3c7;
+    padding-bottom: 0.5rem;
+}
+
+.param-section h3 i {
+    margin-right: 0.5rem;
+    color: #3498db;
+}
+
+.form-group {
+    margin-bottom: 1rem;
+}
+
+.form-group label {
+    display: block;
+    margin-bottom: 0.5rem;
+    font-weight: 600;
+    color: #2c3e50;
+}
+
+.form-group input,
+.form-group select {
+    width: 100%;
+    padding: 0.75rem;
+    border: 2px solid #dee2e6;
+    border-radius: 4px;
+    font-size: 1rem;
+    transition: border-color 0.3s ease;
+}
+
+.form-group input:focus,
+.form-group select:focus {
+    outline: none;
+    border-color: #3498db;
+    box-shadow: 0 0 0 3px rgba(52, 152, 219, 0.1);
+}
+
+/* Simulation Steps */
+.steps-container {
+    display: flex;
+    flex-direction: column;
+    gap: 1.5rem;
+}
+
+.step-item {
+    background: #f8f9fa;
+    border-radius: 8px;
+    border: 1px solid #dee2e6;
+    overflow: hidden;
+    transition: all 0.3s ease;
+}
+
+.step-item:hover {
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+    transform: translateY(-2px);
+}
+
+.step-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 1.5rem;
+    background: #34495e;
+    color: white;
+    cursor: pointer;
+}
+
+.step-header h3 {
+    margin: 0;
+    font-size: 1.2rem;
+    font-weight: 600;
+}
+
+.step-header h3 i {
+    margin-right: 0.5rem;
+    color: #3498db;
+}
+
+.step-content {
+    padding: 1.5rem;
+    background: white;
+    display: none;
+}
+
+.step-content.active {
+    display: block;
+}
+
+.form-row {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 1rem;
+}
+
+/* Toggle Switch */
+.switch {
+    position: relative;
+    display: inline-block;
+    width: 60px;
+    height: 34px;
+}
+
+.switch input {
+    opacity: 0;
+    width: 0;
+    height: 0;
+}
+
+.slider {
+    position: absolute;
+    cursor: pointer;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background-color: #ccc;
+    transition: .4s;
+    border-radius: 34px;
+}
+
+.slider:before {
+    position: absolute;
+    content: "";
+    height: 26px;
+    width: 26px;
+    left: 4px;
+    bottom: 4px;
+    background-color: white;
+    transition: .4s;
+    border-radius: 50%;
+}
+
+input:checked + .slider {
+    background-color: #3498db;
+}
+
+input:checked + .slider:before {
+    transform: translateX(26px);
+}
+
+/* File Generation */
+.generation-controls {
+    display: flex;
+    gap: 1rem;
+    margin-bottom: 2rem;
+    flex-wrap: wrap;
+}
+
+.files-preview {
+    margin-bottom: 2rem;
+}
+
+.files-list {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+    gap: 1rem;
+    margin-top: 1rem;
+}
+
+.file-item {
+    background: #f8f9fa;
+    border: 1px solid #dee2e6;
+    border-radius: 8px;
+    padding: 1rem;
+    transition: all 0.3s ease;
+}
+
+.file-item:hover {
+    background: #e3f2fd;
+    border-color: #3498db;
+    transform: translateY(-2px);
+}
+
+.file-item h4 {
+    color: #2c3e50;
+    margin-bottom: 0.5rem;
+    font-size: 1.1rem;
+}
+
+.file-item p {
+    color: #7f8c8d;
+    font-size: 0.9rem;
+    margin: 0.25rem 0;
+}
+
+.download-section {
+    margin-bottom: 2rem;
+}
+
+.download-options {
+    display: flex;
+    gap: 1rem;
+    flex-wrap: wrap;
+    margin-top: 1rem;
+}
+
+.simulation-summary {
+    background: #f8f9fa;
+    border-radius: 8px;
+    padding: 1.5rem;
+    border: 1px solid #dee2e6;
+}
+
+.summary-content {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+    gap: 1rem;
+    margin-top: 1rem;
+}
+
+.summary-item {
+    background: white;
+    padding: 1rem;
+    border-radius: 4px;
+    border: 1px solid #dee2e6;
+}
+
+.summary-item h4 {
+    color: #2c3e50;
+    margin-bottom: 0.5rem;
+    font-size: 1rem;
+}
+
+.summary-item p {
+    color: #7f8c8d;
+    margin: 0.25rem 0;
+}
+
+/* Checkbox Group Styles */
+.checkbox-group {
+    display: flex;
+    gap: 1rem;
+    margin-top: 0.5rem;
+}
+
+.checkbox-container {
+    display: flex;
+    align-items: center;
+    cursor: pointer;
+    font-size: 0.9rem;
+    color: #495057;
+}
+
+.checkbox-container input[type="checkbox"] {
+    margin-right: 0.5rem;
+    transform: scale(1.2);
+}
+
+.checkbox-container:hover {
+    color: #007bff;
+}
+
+/* Ion Controls */
+.ion-controls {
+    display: flex;
+    gap: 0.5rem;
+    align-items: center;
+}
+
+.ion-controls select {
+    flex: 1;
+}
+
+
+
+
+#ligand-forcefield-section {
+    transition: all 0.3s ease;
+}
+
+#ligand-forcefield-section.disabled {
+    opacity: 0.5;
+    pointer-events: none;
+}
+
+/* Tooltip styling for better text wrapping */
+.tooltip {
+    max-width: 300px;
+}
+
+.tooltip-inner {
+    text-align: left;
+    white-space: normal;
+    word-wrap: break-word;
+}
+
+/* Button Styles */
+.btn {
+    display: inline-flex;
+    align-items: center;
+    padding: 0.75rem 1.5rem;
+    border: none;
+    border-radius: 6px;
+    font-size: 1rem;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    text-decoration: none;
+    gap: 0.5rem;
+}
+
+.btn:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+}
+
+.btn:active {
+    transform: translateY(0);
+}
+
+.btn-primary {
+    background: linear-gradient(135deg, #3498db, #2980b9);
+    color: white;
+}
+
+.btn-primary:hover {
+    background: linear-gradient(135deg, #2980b9, #1f618d);
+}
+
+.btn-secondary {
+    background: linear-gradient(135deg, #95a5a6, #7f8c8d);
+    color: white;
+}
+
+.btn-secondary:hover {
+    background: linear-gradient(135deg, #7f8c8d, #6c7b7d);
+}
+
+.btn-success {
+    background: linear-gradient(135deg, #27ae60, #229954);
+    color: white;
+}
+
+.btn-success:hover {
+    background: linear-gradient(135deg, #229954, #1e8449);
+}
+
+.btn-info {
+    background: linear-gradient(135deg, #17a2b8, #138496);
+    color: white;
+}
+
+.btn-info:hover {
+    background: linear-gradient(135deg, #138496, #117a8b);
+}
+
+.btn i {
+    font-size: 1rem;
+}
+
+/* Footer */
+.footer {
+    background: #2c3e50;
+    color: white;
+    text-align: center;
+    padding: 2rem;
+    margin-top: 2rem;
+}
+
+.footer p {
+    margin: 0;
+    opacity: 0.8;
+}
+
+/* Responsive Design */
+@media (max-width: 768px) {
+    .container {
+        margin: 0;
+        box-shadow: none;
+    }
+    
+    .header-content h1 {
+        font-size: 2rem;
+    }
+    
+    .tab-navigation {
+        flex-direction: column;
+    }
+    
+    .tab-button {
+        min-width: auto;
+        border-bottom: 1px solid #2c3e50;
+    }
+    
+    .main-content {
+        padding: 1rem;
+    }
+    
+    .input-methods {
+        grid-template-columns: 1fr;
+    }
+    
+    .divider {
+        order: 2;
+    }
+    
+    .preview-content {
+        grid-template-columns: 1fr;
+    }
+    
+    .params-grid {
+        grid-template-columns: 1fr;
+    }
+    
+    .form-row {
+        grid-template-columns: 1fr;
+    }
+    
+    .generation-controls {
+        flex-direction: column;
+    }
+    
+    .download-options {
+        flex-direction: column;
+    }
+    
+    .summary-content {
+        grid-template-columns: 1fr;
+    }
+}
+
+@media (max-width: 480px) {
+    .header-content h1 {
+        font-size: 1.5rem;
+    }
+    
+    .card {
+        padding: 1rem;
+    }
+    
+    .card h2 {
+        font-size: 1.5rem;
+    }
+    
+    .btn {
+        padding: 0.5rem 1rem;
+        font-size: 0.9rem;
+    }
+}
+
+/* Loading Animation */
+.loading {
+    display: inline-block;
+    width: 20px;
+    height: 20px;
+    border: 3px solid #f3f3f3;
+    border-top: 3px solid #3498db;
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+/* Structure Preparation Styles */
+.card-description {
+    color: #7f8c8d;
+    margin-bottom: 2rem;
+    font-style: italic;
+}
+
+.prep-sections {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+    gap: 2rem;
+    margin-bottom: 2rem;
+}
+
+.prep-section {
+    background: #f8f9fa;
+    border-radius: 8px;
+    padding: 1.5rem;
+    border: 1px solid #dee2e6;
+}
+
+.prep-section h3 {
+    color: #2c3e50;
+    margin-bottom: 1rem;
+    font-size: 1.2rem;
+    border-bottom: 1px solid #bdc3c7;
+    padding-bottom: 0.5rem;
+}
+
+.prep-section h3 i {
+    margin-right: 0.5rem;
+    color: #3498db;
+}
+
+.prep-options {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+}
+
+.prep-option {
+    background: white;
+    border-radius: 6px;
+    padding: 1rem;
+    border: 1px solid #e1e8ed;
+    transition: all 0.3s ease;
+}
+
+.prep-option:hover {
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+    transform: translateY(-1px);
+}
+
+.checkbox-container {
+    display: flex;
+    align-items: center;
+    cursor: pointer;
+    font-weight: 600;
+    color: #2c3e50;
+    margin-bottom: 0.5rem;
+}
+
+.checkbox-container input[type="checkbox"] {
+    margin-right: 0.75rem;
+    transform: scale(1.2);
+}
+
+.option-description {
+    color: #7f8c8d;
+    font-size: 0.9rem;
+    margin: 0;
+    margin-left: 1.5rem;
+}
+
+.prep-actions {
+    display: flex;
+    gap: 1rem;
+    margin-bottom: 2rem;
+    flex-wrap: wrap;
+}
+
+.prep-status {
+    background: #e8f5e8;
+    border: 1px solid #c3e6cb;
+    border-radius: 8px;
+    padding: 1.5rem;
+    margin-bottom: 2rem;
+}
+
+.prep-status h3 {
+    color: #155724;
+    margin-bottom: 1rem;
+}
+
+.status-content {
+    color: #155724;
+}
+
+.prepared-structure-preview {
+    background: #f8f9fa;
+    border-radius: 8px;
+    padding: 1.5rem;
+    border: 1px solid #dee2e6;
+    margin-top: 2rem;
+}
+
+.prepared-structure-preview h3 {
+    color: #2c3e50;
+    margin-bottom: 1rem;
+    font-size: 1.2rem;
+}
+
+.structure-info p {
+    margin: 0.5rem 0;
+    font-size: 1rem;
+}
+
+.structure-visualization {
+    margin-top: 1rem;
+}
+
+#prepared-ngl-viewer {
+    border-radius: 4px;
+    background: #f8f9fa;
+    border: 1px solid #dee2e6;
+}
+
+/* Custom Checkbox Styles */
+.checkbox-container input[type="checkbox"] {
+    appearance: none;
+    width: 20px;
+    height: 20px;
+    border: 2px solid #bdc3c7;
+    border-radius: 4px;
+    background: white;
+    position: relative;
+    cursor: pointer;
+    transition: all 0.3s ease;
+}
+
+.checkbox-container input[type="checkbox"]:checked {
+    background: #3498db;
+    border-color: #3498db;
+}
+
+.checkbox-container input[type="checkbox"]:checked::after {
+    content: '✓';
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    color: white;
+    font-weight: bold;
+    font-size: 14px;
+}
+
+.checkbox-container input[type="checkbox"]:hover {
+    border-color: #3498db;
+    box-shadow: 0 0 0 3px rgba(52, 152, 219, 0.1);
+}
+
+/* Responsive Design for Structure Prep */
+@media (max-width: 768px) {
+    .prep-sections {
+        grid-template-columns: 1fr;
+    }
+    
+    .prep-actions {
+        flex-direction: column;
+    }
+    
+    .prep-option {
+        padding: 0.75rem;
+    }
+    
+    .option-description {
+        margin-left: 1.25rem;
+    }
+}
+
+/* Utility Classes */
+.text-center { text-align: center; }
+.text-left { text-align: left; }
+.text-right { text-align: right; }
+.mt-1 { margin-top: 0.5rem; }
+.mt-2 { margin-top: 1rem; }
+.mt-3 { margin-top: 1.5rem; }
+.mb-1 { margin-bottom: 0.5rem; }
+.mb-2 { margin-bottom: 1rem; }
+.mb-3 { margin-bottom: 1.5rem; }
+.p-1 { padding: 0.5rem; }
+.p-2 { padding: 1rem; }
+.p-3 { padding: 1.5rem; }

html/index.html

@@ -0,0 +1,587 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>MD Simulation Pipeline</title>
+    <link rel="stylesheet" href="../css/styles.css">
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css" rel="stylesheet">
+    <!-- NGL 3D Molecular Viewer -->
+    <script src="https://unpkg.com/ngl@2.0.0-dev.35/dist/ngl.js"></script>
+</head>
+<body>
+    <div class="container">
+        <!-- Header -->
+        <header class="header">
+            <div class="header-content">
+                <h1><i class="fas fa-atom"></i> MD Simulation Pipeline</h1>
+                <p>Molecular Dynamics Simulation Setup and File Generation</p>
+            </div>
+        </header>
+
+        <!-- Navigation Tabs -->
+        <nav class="tab-navigation">
+            <button class="tab-button active" data-tab="protein-loading">
+                <i class="fas fa-upload"></i> Protein Loading
+            </button>
+            <button class="tab-button" data-tab="structure-prep">
+                <i class="fas fa-tools"></i> Structure Preparation
+            </button>
+            <button class="tab-button" data-tab="simulation-params">
+                <i class="fas fa-cogs"></i> Simulation Parameters
+            </button>
+            <button class="tab-button" data-tab="simulation-steps">
+                <i class="fas fa-list-ol"></i> Simulation Steps
+            </button>
+            <button class="tab-button" data-tab="file-generation">
+                <i class="fas fa-file-download"></i> Generate Files
+            </button>
+        </nav>
+
+        <!-- Main Content -->
+        <main class="main-content">
+            <!-- Protein Loading Tab -->
+            <div id="protein-loading" class="tab-content active">
+                <div class="card">
+                    <h2><i class="fas fa-dna"></i> Protein Structure Input</h2>
+                    
+                    <div class="input-methods">
+                        <div class="method-option">
+                            <h3><i class="fas fa-file-upload"></i> Upload PDB File</h3>
+                            <div class="file-upload-area" id="file-upload-area">
+                                <i class="fas fa-cloud-upload-alt"></i>
+                                <p>Drag and drop your PDB file here or click to browse</p>
+                                <input type="file" id="pdb-file" accept=".pdb,.ent" style="display: none;">
+                                <button type="button" class="btn btn-secondary" id="choose-file-btn">
+                                    Choose File
+                                </button>
+                            </div>
+                            <div id="file-info" class="file-info" style="display: none;">
+                                <p><strong>Selected file:</strong> <span id="file-name"></span></p>
+                                <p><strong>Size:</strong> <span id="file-size"></span></p>
+                            </div>
+                        </div>
+
+                        <div class="divider">
+                            <span>OR</span>
+                        </div>
+
+                        <div class="method-option">
+                            <h3><i class="fas fa-database"></i> Fetch from PDB</h3>
+                            <div class="pdb-fetch">
+                                <div class="input-group">
+                                    <label for="pdb-id">PDB ID:</label>
+                                    <input type="text" id="pdb-id" placeholder="e.g., 1CRN, 1HTM" maxlength="4">
+                                    <button type="button" class="btn btn-primary" id="fetch-pdb">
+                                        <i class="fas fa-download"></i> Fetch
+                                    </button>
+                                </div>
+                                <div id="pdb-status" class="status-message"></div>
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="protein-preview" id="protein-preview" style="display: none;">
+                        <h3><i class="fas fa-eye"></i> Protein Preview</h3>
+                        <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>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>
+                                <p><strong>Ions:</strong> <span id="ion-count"></span></p>
+                                <p><strong>Ligands:</strong> <span id="ligand-info"></span></p>
+                                <p><strong>HETATM entries:</strong> <span id="hetatm-count"></span></p>
+                            </div>
+                            <div class="protein-visualization">
+                                <div id="molecule-viewer" class="molecule-viewer">
+                                    <!-- 3D visualization will be added here -->
+                                    <div id="ngl-viewer" style="width: 100%; height: 100%; min-height: 300px;"></div>
+                                    <div id="viewer-controls" class="viewer-controls" style="display: none;">
+                                        <button class="btn btn-sm btn-secondary" onclick="mdPipeline.resetView()">
+                                            <i class="fas fa-home"></i> Reset View
+                                        </button>
+                                        <button class="btn btn-sm btn-secondary" onclick="mdPipeline.toggleRepresentation()">
+                                            <i class="fas fa-eye"></i> <span id="style-text">Mixed View</span>
+                                        </button>
+                                        <button class="btn btn-sm btn-secondary" onclick="mdPipeline.toggleSpin()">
+                                            <i class="fas fa-sync"></i> Spin
+                                        </button>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Structure Preparation Tab -->
+            <div id="structure-prep" class="tab-content">
+                <div class="card">
+                    <h2><i class="fas fa-tools"></i> Structure Preparation for AMBER</h2>
+                    <p class="card-description">Prepare the protein structure for AMBER force field generation by cleaning and modifying the PDB file.</p>
+                    
+                    <div class="prep-sections">
+                        <div class="prep-section">
+                            <h3><i class="fas fa-trash"></i> Remove Components</h3>
+                            <div class="prep-options">
+                                <div class="prep-option">
+                                    <label class="checkbox-container">
+                                        <input type="checkbox" id="remove-water" checked>
+                                        <span class="checkmark"></span>
+                                        Remove water molecules
+                                    </label>
+                                    <p class="option-description">Remove all water molecules (HOH, WAT, TIP3, etc.) from the structure</p>
+                                </div>
+                                
+                                <div class="prep-option">
+                                    <label class="checkbox-container">
+                                        <input type="checkbox" id="remove-ions" checked>
+                                        <span class="checkmark"></span>
+                                        Remove ions
+                                    </label>
+                                    <p class="option-description">Remove all ions (Na+, Cl-, K+, Mg2+, etc.) from the structure</p>
+                                </div>
+                                
+                                <div class="prep-option">
+                                    <label class="checkbox-container">
+                                        <input type="checkbox" id="remove-hydrogens" checked>
+                                        <span class="checkmark"></span>
+                                        Remove hydrogen atoms
+                                    </label>
+                                    <p class="option-description">Remove all hydrogen atoms from the protein structure</p>
+                                </div>
+                            </div>
+                        </div>
+
+                        <div class="prep-section">
+                            <h3><i class="fas fa-plus-circle"></i> Add Capping Groups and Select Protein  Chains</h3>
+                            <div class="prep-options">
+                                <div class="prep-option">
+                                    <label class="checkbox-container">
+                                        <input type="checkbox" id="add-nme" checked>
+                                        <span class="checkmark"></span>
+                                        Add NME group (C-terminal)
+                                    </label>
+                                    <p class="option-description">Add N-methyl amide (NME) group to C-terminal residues</p>
+                                </div>
+                                
+                                <div class="prep-option">
+                                    <label class="checkbox-container">
+                                        <input type="checkbox" id="add-ace" checked>
+                                        <span class="checkmark"></span>
+                                        Add ACE group (N-terminal)
+                                    </label>
+                                    <p class="option-description">Add acetyl (ACE) group to N-terminal residues</p>
+                                </div>
+
+                                <div class="form-group">
+                                    <label>Preserve Chains for FF Generation:</label>
+                                    <div id="chain-selection" class="multi-checkbox-group">
+                                        <!-- Chain checkboxes will be rendered here -->
+                                    </div>
+                                    <small class="form-help">Select one or more protein chains to include in preparation</small>
+                                </div>
+                            </div>
+                        </div>
+
+                        <div class="prep-section">
+                            <h3><i class="fas fa-pills"></i> Ligand Handling</h3>
+                            <div class="prep-options">
+                                <div class="prep-option">
+                                    <label class="checkbox-container">
+                                        <input type="checkbox" id="preserve-ligands">
+                                        <span class="checkmark"></span>
+                                        Preserve ligands
+                                    </label>
+                                    <p class="option-description">Keep ligands in the structure and append them at the end</p>
+                                </div>
+                                
+                                <div class="prep-option">
+                                    <div class="checkbox-with-button">
+                                        <label class="checkbox-container">
+                                            <input type="checkbox" id="separate-ligands">
+                                            <span class="checkmark"></span>
+                                            Create separate ligand file
+                                        </label>
+                                        <button class="btn btn-sm btn-outline-primary" id="download-ligand" disabled>
+                                            <i class="fas fa-download"></i>
+                                        </button>
+                                    </div>
+                                    <p class="option-description">Extract ligands to a separate PDB file for individual processing</p>
+                                </div>
+                                
+                                <div class="form-group">
+                                    <label>Select Ligands to Preserve</label>
+                                    <div id="ligand-selection" class="multi-checkbox-group">
+                                        <!-- Ligand checkboxes will be rendered here -->
+                                    </div>
+                                    <small class="form-help">Tick ligands to include. Unselected ligands will be ignored.</small>
+                                </div>
+                            </div>
+                        </div>
+
+                    </div>
+
+                    <div class="prep-actions">
+                        <button class="btn btn-primary" id="prepare-structure">
+                            <i class="fas fa-magic"></i> Prepare Structure
+                        </button>
+                        <button class="btn btn-secondary" id="preview-prepared">
+                            <i class="fas fa-eye"></i> Preview Prepared Structure
+                        </button>
+                        <button class="btn btn-info" id="download-prepared">
+                            <i class="fas fa-download"></i> Download Prepared PDB
+                        </button>
+                    </div>
+
+                    <div class="prep-status" id="prep-status" style="display: none;">
+                        <h3><i class="fas fa-info-circle"></i> Preparation Status</h3>
+                        <div class="status-content" id="prep-status-content">
+                            <!-- Status information will be displayed here -->
+                        </div>
+                    </div>
+
+                    <div class="prepared-structure-preview" id="prepared-structure-preview" style="display: none;">
+                        <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>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>
+                            </div>
+                            <div class="structure-visualization">
+                                <div id="prepared-molecule-viewer" class="molecule-viewer">
+                                    <div id="prepared-ngl-viewer" style="width: 100%; height: 100%; min-height: 300px;"></div>
+                                    <div id="prepared-viewer-controls" class="viewer-controls" style="display: none;">
+                                        <button class="btn btn-sm btn-secondary" onclick="mdPipeline.resetPreparedView()">
+                                            <i class="fas fa-home"></i> Reset View
+                                        </button>
+                                        <button class="btn btn-sm btn-secondary" onclick="mdPipeline.togglePreparedRepresentation()">
+                                            <i class="fas fa-eye"></i> <span id="prepared-style-text">Mixed View</span>
+                                        </button>
+                                        <button class="btn btn-sm btn-secondary" onclick="mdPipeline.togglePreparedSpin()">
+                                            <i class="fas fa-sync"></i> Spin
+                                        </button>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Simulation Parameters Tab -->
+            <div id="simulation-params" class="tab-content">
+                <div class="card">
+                    <h2><i class="fas fa-sliders-h"></i> Simulation Parameters</h2>
+                    
+                    <div class="params-grid">
+                        <div class="param-section">
+                            <h3><i class="fas fa-cube"></i> System Setup</h3>
+                            <div class="form-group">
+                                <label for="box-type">Box Type:</label>
+                                <select id="box-type">
+                                    <option value="cuboid">Cuboid</option>
+                                </select>
+                            </div>
+                            <div class="form-group">
+                                <label for="box-size">
+                                    Distance (Å):
+                                    <i class="fas fa-info-circle" 
+                                       style="color: #007bff; margin-left: 5px; cursor: help;" 
+                                       data-toggle="tooltip" 
+                                       data-placement="top"
+                                       data-html="true"
+              title="The minimum distance between any atom originally present in solute and the edge of the periodic box is given by the distance parameter.">
+                                    </i>
+                                </label>
+                                <input type="number" id="box-size" value="10" step="1" min="5">
+                            </div>
+                        </div>
+
+                        <div class="param-section" id="ligand-forcefield-section" style="display: none;">
+                            <h3><i class="fas fa-atom"></i> Ligand Force Field</h3>
+                            <div class="form-group">
+                                <label for="ligand-forcefield">Ligand Force Field:</label>
+                                <select id="ligand-forcefield">
+                                    <option value="gaff2">gaff2</option>
+                                    <option value="gaff">gaff</option>
+                                </select>
+                            </div>
+                            <div class="form-group">
+                                <button type="button" class="btn btn-primary" onclick="mdPipeline.generateLigandFF(event)">
+                                    <i class="fas fa-cogs"></i> Generate FF for Ligand
+                                </button>
+                            </div>
+                        </div>
+
+                        <div class="param-section">
+                            <h3><i class="fas fa-flask"></i> Force Field & Water Model</h3>
+                            <div class="form-group">
+                                <label for="force-field">Protein Force Field:</label>
+                                <select id="force-field">
+                                    <option value="ff14SB">ff14SB</option>
+                                    <option value="ff19SB">ff19SB</option>
+                                </select>
+                            </div>
+                            <div class="form-group">
+                                <label for="water-model">Water Model:</label>
+                                <select id="water-model">
+                                    <option value="tip3p">TIP3P</option>
+                                    <option value="spce">SPCE</option>
+                                </select>
+                            </div>
+                            <div class="form-group">
+                                <label for="add-ions">Add Ions:</label>
+                                <div class="ion-controls">
+                                    <select id="add-ions">
+                                        <option value="None">None</option>
+                                        <option value="Na+">Na+</option>
+                                        <option value="Cl-">Cl-</option>
+                                    </select>
+                                    <button type="button" class="btn btn-sm btn-outline-primary" onclick="mdPipeline.calculateNetCharge(event)">
+                                        <i class="fas fa-calculator"></i> Net Charge
+                                    </button>
+                                </div>
+                            </div>
+                        </div>
+
+                        <div class="param-section">
+                            <h3><i class="fas fa-thermometer-half"></i> Temperature & Pressure</h3>
+                            <div class="form-group">
+                                <label for="temperature">Temperature (K):</label>
+                                <input type="number" id="temperature" value="300" step="5" min="200" max="400">
+                            </div>
+                            <div class="form-group">
+                                <label for="pressure">Pressure (atm):</label>
+                                <input type="number" id="pressure" value="1.0" step="0.1" min="0.1">
+                            </div>
+                            <div class="form-group">
+                                <label for="coupling-type">Thermostat:</label>
+                                <select id="coupling-type">
+                                    <option value="langevin">Langevin</option>
+                                </select>
+                            </div>
+                        </div>
+
+                        <div class="param-section">
+                            <h3><i class="fas fa-clock"></i> Integration Parameters</h3>
+                            <div class="form-group">
+                                <label for="timestep">Time Step (ps):</label>
+                                <input type="number" id="timestep" value="0.002" step="0.001" min="0.001" max="0.005">
+                            </div>
+                            <div class="form-group">
+                                <label for="cutoff">Cutoff Distance (Ang):</label>
+                                <input type="number" id="cutoff" value="10.0" step="1" min="8" max="20">
+                            </div>
+                            <div class="form-group">
+                                <label for="electrostatic">Electrostatic:</label>
+                                <select id="electrostatic">
+                                    <option value="pme">PME</option>
+                                </select>
+                            </div>
+                        </div>
+
+                    </div>
+                </div>
+            </div>
+
+            <!-- Simulation Steps Tab -->
+            <div id="simulation-steps" class="tab-content">
+                <div class="card">
+                    <h2><i class="fas fa-list-ol"></i> Simulation Steps Configuration</h2>
+                    
+                    <div class="steps-container">
+                        <div class="step-item">
+                            <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>
+                                    <span class="slider"></span>
+                                </label>
+                            </div>
+                            <div class="step-content" id="restrained-min-content">
+                                <div class="form-row">
+                                    <div class="form-group">
+                                        <label for="restrained-steps">Steps:</label>
+                                        <input type="number" id="restrained-steps" value="10000" step="100" min="100">
+                                    </div>
+                                    <div class="form-group">
+                                        <label for="restrained-force">Force Constant (kJ/mol/Ų):</label>
+                                        <input type="number" id="restrained-force" value="10" step="1" min="1">
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+
+                        <div class="step-item">
+                            <div class="step-header">
+                                <h3><i class="fas fa-compress"></i> Minimization</h3>
+                                <label class="switch">
+                                    <input type="checkbox" id="enable-minimization" checked>
+                                    <span class="slider"></span>
+                                </label>
+                            </div>
+                            <div class="step-content" id="minimization-content">
+                                <div class="form-row">
+                                    <div class="form-group">
+                                        <label for="min-steps">Steps:</label>
+                                        <input type="number" id="min-steps" value="20000" step="500" min="1000">
+                                    </div>
+                                    <div class="form-group">
+                                        <label for="min-algorithm">Algorithm:</label>
+                                        <select id="min-algorithm">
+                                            <option value="cg">Conjugate Gradient</option>
+                                        </select>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+
+                        <div class="step-item">
+                            <div class="step-header">
+                                <h3><i class="fas fa-fire"></i> NPT Heating</h3>
+                                <label class="switch">
+                                    <input type="checkbox" id="enable-nvt" checked>
+                                    <span class="slider"></span>
+                                </label>
+                            </div>
+                            <div class="step-content" id="nvt-content">
+                                <div class="form-row">
+                                    <div class="form-group">
+                                        <label for="nvt-steps">Steps:</label>
+                                        <input type="number" id="nvt-steps" value="50000" step="5000" min="10000">
+                                    </div>
+                                    <div class="form-group">
+                                        <label for="nvt-temp">Target Temperature (K):</label>
+                                        <input type="number" id="nvt-temp" value="300" step="5" min="200">
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+
+                        <div class="step-item">
+                            <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>
+                                    <span class="slider"></span>
+                                </label>
+                            </div>
+                            <div class="step-content" id="npt-content">
+                                <div class="form-row">
+                                    <div class="form-group">
+                                        <label for="npt-steps">Steps:</label>
+                                        <input type="number" id="npt-steps" value="100000" step="10000" min="20000">
+                                    </div>
+                                    <div class="form-group">
+                                        <label for="npt-temp">Temperature (K):</label>
+                                        <input type="number" id="npt-temp" value="300" step="5" min="200">
+                                    </div>
+                                    <div class="form-group">
+                                        <label for="npt-pressure">Pressure (atm):</label>
+                                        <input type="number" id="npt-pressure" value="1.0" step="0.1" min="0.1">
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+
+                        <div class="step-item">
+                            <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>
+                                    <span class="slider"></span>
+                                </label>
+                            </div>
+                            <div class="step-content" id="production-content">
+                                <div class="form-row">
+                                    <div class="form-group">
+                                        <label for="prod-steps">Steps:</label>
+                                        <input type="number" id="prod-steps" value="1000000" step="100000" min="100000">
+                                    </div>
+                                    <div class="form-group">
+                                        <label for="prod-temp">Temperature (K):</label>
+                                        <input type="number" id="prod-temp" value="300" step="5" min="200">
+                                    </div>
+                                    <div class="form-group">
+                                        <label for="prod-pressure">Pressure (atm):</label>
+                                        <input type="number" id="prod-pressure" value="1.0" step="0.1" min="0.1">
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- File Generation Tab -->
+            <div id="file-generation" class="tab-content">
+                <div class="card">
+                    <h2><i class="fas fa-file-download"></i> Generate Simulation Files</h2>
+                    
+                    <div class="generation-controls">
+                        <button class="btn btn-primary" id="generate-files">
+                            <i class="fas fa-magic"></i> Generate All Files
+                        </button>
+                        <button class="btn btn-secondary" id="preview-files">
+                            <i class="fas fa-eye"></i> Preview Files
+                        </button>
+                        <button class="btn btn-info" id="preview-solvated">
+                            <i class="fas fa-tint"></i> Preview 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 class="files-list" id="files-list">
+                            <!-- Generated files will be listed here -->
+                        </div>
+                    </div>
+
+                    <div class="download-section" id="download-section" style="display: none;">
+                        <h3><i class="fas fa-download"></i> Download Files</h3>
+                        <div class="download-options">
+                            <button class="btn btn-success" id="download-zip">
+                                <i class="fas fa-file-archive"></i> Download All as ZIP
+                            </button>
+                            
+                        </div>
+                    </div>
+
+                    <div class="simulation-summary" id="simulation-summary" style="display: none;">
+                        <h3><i class="fas fa-chart-line"></i> Simulation Summary</h3>
+                        <div class="summary-content" id="summary-content">
+                            <!-- Simulation summary will be displayed here -->
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </main>
+        
+        <!-- Step Navigation Controls -->
+        <div class="step-navigation">
+            <button class="nav-btn prev-btn" id="prev-tab" disabled>
+                <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>
+            </div>
+            <button class="nav-btn next-btn" id="next-tab">
+                Next <i class="fas fa-chevron-right"></i>
+            </button>
+        </div>
+
+        <!-- Footer -->
+        <footer class="footer">
+            <p>&copy; 2024 MD Simulation Pipeline. Built for molecular dynamics simulations.</p>
+        </footer>
+    </div>
+
+    <script src="../js/script.js"></script>
+</body>
+</html>

js/script.js

@@ -0,0 +1,2216 @@
+// 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');
+            }
+
+            // Create a new window to display the solvated protein
+            const previewWindow = window.open('', '_blank', 'width=1200,height=800');
+            previewWindow.document.write(`
+                <!DOCTYPE html>
+                <html>
+                <head>
+                    <title>Solvated Protein Preview</title>
+                    <script src="https://unpkg.com/ngl@2.0.0-dev.35/dist/ngl.js"></script>
+                    <style>
+                        body { margin: 0; padding: 20px; font-family: Arial, sans-serif; background: #f5f5f5; }
+                        .header { background: white; padding: 20px; border-radius: 8px; margin-bottom: 20px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+                        .viewer-container { background: white; border-radius: 8px; padding: 20px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+                        #ngl-viewer { width: 100%; height: 600px; border: 1px solid #ddd; border-radius: 4px; }
+                        .controls { margin-top: 15px; }
+                        .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; }
+                        .btn-info { background: #17a2b8; color: white; }
+                        .loading { text-align: center; padding: 50px; color: #666; }
+                        .error { color: #dc3545; background: #f8d7da; padding: 15px; border-radius: 4px; margin: 20px 0; }
+                        .retry-btn { background: #28a745; color: white; padding: 10px 20px; border: none; border-radius: 4px; cursor: pointer; margin-top: 10px; }
+                    </style>
+                </head>
+                <body>
+                    <div class="header">
+                        <h2>💧 Solvated Protein Structure</h2>
+                        <p>This is the protein structure after solvation with water molecules and ions.</p>
+                    </div>
+                    <div class="viewer-container">
+                        <div id="ngl-viewer">
+                            <div class="loading">Loading 3D viewer...</div>
+                        </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-info" onclick="toggleSpin()">Toggle Spin</button>
+                        </div>
+                    </div>
+                    <script>
+                        let stage;
+                        let currentRepresentation = 'cartoon';
+                        let isSpinning = false;
+                        let pdbContent = \`${data.content}\`;
+
+                        // Wait for NGL to load with multiple fallbacks
+                        function waitForNGL() {
+                            return new Promise((resolve, reject) => {
+                                // Check if NGL is already available
+                                if (typeof NGL !== 'undefined') {
+                                    resolve();
+                                    return;
+                                }
+
+                                let attempts = 0;
+                                const maxAttempts = 100; // 10 seconds max
+                                
+                                const checkNGL = () => {
+                                    attempts++;
+                                    if (typeof NGL !== 'undefined') {
+                                        resolve();
+                                    } else if (attempts >= maxAttempts) {
+                                        // Try alternative CDN
+                                        loadAlternativeNGL().then(resolve).catch(() => {
+                                            reject(new Error('NGL.js failed to load from all sources'));
+                                        });
+                                    } else {
+                                        setTimeout(checkNGL, 100);
+                                    }
+                                };
+                                
+                                checkNGL();
+                            });
+                        }
+
+                        // Fallback to alternative CDN
+                        function loadAlternativeNGL() {
+                            return new Promise((resolve, reject) => {
+                                const script = document.createElement('script');
+                                script.src = 'https://cdn.jsdelivr.net/npm/ngl@2.0.0-dev.35/dist/ngl.js';
+                                script.onload = () => {
+                                    if (typeof NGL !== 'undefined') {
+                                        resolve();
+                                    } else {
+                                        reject(new Error('Alternative CDN failed'));
+                                    }
+                                };
+                                script.onerror = () => reject(new Error('Alternative CDN failed'));
+                                document.head.appendChild(script);
+                            });
+                        }
+
+                        async function initViewer() {
+                            try {
+                                // Wait for NGL to be available
+                                await waitForNGL();
+                                
+                                // Clear loading message
+                                document.getElementById('ngl-viewer').innerHTML = '';
+
+                                stage = new NGL.Stage("ngl-viewer", {
+                                    backgroundColor: "white",
+                                    quality: "medium"
+                                });
+
+                                // Create a blob from PDB content
+                                const blob = new Blob([pdbContent], { type: 'text/plain' });
+                                const url = URL.createObjectURL(blob);
+
+                                // Load the structure
+                                const component = await stage.loadFile(url, {
+                                    ext: "pdb",
+                                    defaultRepresentation: false
+                                });
+
+                                // 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
+                                });
+
+                                // (Ions not explicitly rendered to avoid overriding visuals)
+
+                                // Add ball and stick for ligands
+                                component.addRepresentation("ball+stick", {
+                                    sele: "hetero",
+                                    color: "element",
+                                    radius: 0.15
+                                });
+
+                                // Single combined viewer PDB already includes ligand as HETATM
+
+                                // Auto-fit the view
+                                stage.autoView();
+
+                                // Clean up the blob URL
+                                URL.revokeObjectURL(url);
+
+                            } catch (error) {
+                                console.error('Error loading structure:', error);
+                                document.getElementById('ngl-viewer').innerHTML = 
+                                    '<div class="error">' +
+                                    '<strong>Error:</strong> Failed to load solvated protein: ' + error.message + '<br>' +
+                                    '<button class="retry-btn" onclick="retryLoad()">Retry Loading</button>' +
+                                    '</div>';
+                            }
+                        }
+
+                        function retryLoad() {
+                            document.getElementById('ngl-viewer').innerHTML = '<div class="loading">Retrying...</div>';
+                            initViewer();
+                        }
+
+                        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
+                                });
+                                // (Ions not explicitly rendered to avoid overriding visuals)
+                                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>
+            `);
+            previewWindow.document.close();
+
+        } 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

@@ -0,0 +1,1549 @@
+#!/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("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('/')
+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)

python/structure_preparation.py

@@ -0,0 +1,693 @@
+#!/usr/bin/env python3
+"""
+AMBER Structure Preparation Script using MDAnalysis
+Complete pipeline: extract protein, add caps, handle ligands
+"""
+
+import os
+import subprocess
+import sys
+import shutil
+
+def run_command(cmd, description=""):
+    """Run a command and return success status"""
+    try:
+        print(f"Running: {description}")
+        print(f"Command: {cmd}")
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=120)
+        print(f"Return code: {result.returncode}")
+        if result.stdout:
+            print(f"STDOUT: {result.stdout}")
+        if result.stderr:
+            print(f"STDERR: {result.stderr}")
+        if result.returncode != 0:
+            print(f"Error: {result.stderr}")
+            return False
+        return True
+    except subprocess.TimeoutExpired:
+        print(f"Timeout: {description}")
+        return False
+    except Exception as e:
+        print(f"Error running {description}: {str(e)}")
+        return False
+
+def extract_protein_only(pdb_content, output_file, selected_chains=None):
+    """Extract protein without hydrogens using MDAnalysis. Optionally restrict to selected chains."""
+    # Write input content to output file first
+    with open(output_file, 'w') as f:
+        f.write(pdb_content)
+    
+    try:
+        # Run MDAnalysis command with the output file as input
+        chain_sel = ''
+        if selected_chains:
+            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}\')"'
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=60)
+        
+        if result.returncode != 0:
+            raise Exception(f"MDAnalysis error: {result.stderr}")
+        
+        return True
+    except Exception as e:
+        print(f"Error in extract_protein_only: {e}")
+        return False
+
+def add_capping_groups(input_file, output_file):
+    """Add ACE and NME capping groups using 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}"
+    if not run_command(cmd, f"Adding capping groups to {input_file}"):
+        return False
+    
+    # Then add TER cards using awk
+    cmd = f"awk '/NME/{{nme=NR}} /ACE/ && nme && NR > nme {{print \"TER\"; nme=0}} {{print}}' {temp_capped} > {output_file}"
+    if not run_command(cmd, f"Adding TER cards to {temp_capped}"):
+        return False
+    
+    # Clean up temp file
+    if os.path.exists(temp_capped):
+        os.remove(temp_capped)
+    
+    return True
+
+def extract_selected_chains(pdb_content, output_file, selected_chains):
+    """Extract selected chains using PyMOL commands"""
+    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 chain selection string
+        chain_filters = ' or '.join([f'chain {c}' for c in selected_chains])
+        selection = f"({chain_filters}) and polymer.protein"
+        
+        # Use PyMOL to extract chains
+        cmd = f'''python -c "
+import pymol
+pymol.finish_launching(['pymol', '-c'])
+pymol.cmd.load('{temp_input}')
+pymol.cmd.save('{output_file}', '{selection}')
+pymol.cmd.quit()
+"'''
+        
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=60)
+        
+        # Clean up temp file
+        if os.path.exists(temp_input):
+            os.remove(temp_input)
+        
+        if result.returncode != 0:
+            print(f"PyMOL chain extraction error: {result.stderr}")
+            return False
+        
+        return True
+    except Exception as e:
+        print(f"Error extracting selected chains: {e}")
+        return False
+
+def extract_selected_ligands(pdb_content, output_file, selected_ligands):
+    """Extract selected ligands using PyMOL commands"""
+    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
+        parts = []
+        for lig in selected_ligands:
+            resn = lig.get('resn', '').strip()
+            chain = lig.get('chain', '').strip()
+            if resn and chain:
+                parts.append(f"(resn {resn} and chain {chain})")
+            elif resn:
+                parts.append(f"resn {resn}")
+        
+        if not parts:
+            # No ligands to extract
+            with open(output_file, 'w') as f:
+                f.write('\n')
+            return True
+        
+        selection = ' or '.join(parts)
+        
+        # Use PyMOL to extract ligands
+        cmd = f'''python -c "
+import pymol
+pymol.finish_launching(['pymol', '-c'])
+pymol.cmd.load('{temp_input}')
+pymol.cmd.save('{output_file}', '{selection}')
+pymol.cmd.quit()
+"'''
+        
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=60)
+        
+        # Clean up temp file
+        if os.path.exists(temp_input):
+            os.remove(temp_input)
+        
+        if result.returncode != 0:
+            print(f"PyMOL ligand extraction error: {result.stderr}")
+            return False
+        
+        return True
+    except Exception as e:
+        print(f"Error extracting selected ligands: {e}")
+        return False
+
+def extract_ligands(pdb_content, output_file, ligand_residue_name=None, selected_ligands=None):
+    """Extract ligands using MDAnalysis. Optionally restrict to selected ligands (list of dicts with resn, chain, resi)."""
+    # Write input content to output file first
+    with open(output_file, 'w') as f:
+        f.write(pdb_content)
+    
+    try:
+        # Run MDAnalysis command with the output file as input
+        if selected_ligands:
+            # Build selection from provided ligand list (RESN-CHAIN groups)
+            parts = []
+            for lig in selected_ligands:
+                resn = lig.get('resn', '').strip()
+                chain = lig.get('chain', '').strip()
+                if resn and chain:
+                    parts.append(f"(resname {resn} and segid {chain})")
+                elif resn:
+                    parts.append(f"resname {resn}")
+            if parts:
+                selection = ' or '.join(parts)
+                cmd = f'''python -c "
+import MDAnalysis as mda
+u = mda.Universe('{output_file}')
+u.select_atoms('{selection}').write('{output_file}')
+"'''
+            else:
+                cmd = f"python -c \"open('{output_file}','w').write('\\n')\""
+        elif ligand_residue_name:
+            # Use specified ligand residue name - extract from both ATOM and HETATM records
+            cmd = f'''python -c "
+import MDAnalysis as mda
+u = mda.Universe('{output_file}')
+# Extract specific ligand residue from both ATOM and HETATM records
+u.select_atoms('resname {ligand_residue_name}').write('{output_file}')
+"'''
+        else:
+            # Auto-detect ligand residues
+            cmd = f'''python -c "
+import MDAnalysis as mda
+u = mda.Universe('{output_file}')
+# Get all unique residue names from HETATM records
+hetatm_residues = set()
+for atom in u.atoms:
+    if atom.record_type == 'HETATM':
+        hetatm_residues.add(atom.resname)
+# Remove water and ions
+ligand_residues = hetatm_residues - {{'HOH', 'WAT', 'TIP3', 'TIP4', 'SPC', 'SPCE', 'NA', 'CL', 'K', 'MG', 'CA', 'ZN', 'FE', 'MN', 'CU', 'NI', 'CO', 'CD', 'HG', 'PB', 'SR', 'BA', 'RB', 'CS', 'LI', 'F', 'BR', 'I', 'PO4', 'PO3', 'H2PO4', 'HPO4', 'H3PO4', 'SO4'}}
+if ligand_residues:
+    resname_sel = ' or '.join([f'resname {{res}}' for res in ligand_residues])
+    u.select_atoms(resname_sel).write('{output_file}')
+else:
+    # No ligands found, create empty file
+    with open('{output_file}', 'w') as f:
+        f.write('\\n')
+"'''
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=60)
+        
+        if result.returncode != 0:
+            raise Exception(f"MDAnalysis error: {result.stderr}")
+        
+        # If specific ligand residue name was provided, convert ATOM to HETATM
+        if ligand_residue_name:
+            convert_atom_to_hetatm(output_file)
+        
+        return True
+    except Exception as e:
+        print(f"Error in extract_ligands: {e}")
+        return False
+
+def convert_atom_to_hetatm(pdb_file):
+    """Convert ATOM records to HETATM in PDB file"""
+    try:
+        with open(pdb_file, 'r') as f:
+            lines = f.readlines()
+        
+        # Convert ATOM to HETATM
+        converted_lines = []
+        for line in lines:
+            if line.startswith('ATOM'):
+                # Replace ATOM with HETATM
+                converted_line = 'HETATM' + line[6:]
+                converted_lines.append(converted_line)
+            else:
+                converted_lines.append(line)
+        
+        # Write back to file
+        with open(pdb_file, 'w') as f:
+            f.writelines(converted_lines)
+        
+        print(f"Converted ATOM records to HETATM in {pdb_file}")
+        return True
+    except Exception as e:
+        print(f"Error converting ATOM to HETATM: {e}")
+        return False
+
+def correct_ligand_with_pymol(ligand_file, corrected_file):
+    """Correct ligand using PyMOL"""
+    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")
+
+def remove_connect_records(pdb_file):
+    """Remove CONNECT 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')]
+        
+        with open(pdb_file, 'w') as f:
+            f.writelines(filtered_lines)
+        
+        print(f"Removed CONNECT records from {pdb_file}")
+        return True
+    except Exception as e:
+        print(f"Error removing CONNECT 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"""
+    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()
+        
+        # Process protein file: remove 'END' and add properly formatted 'TER'
+        protein_processed = []
+        last_atom_line = None
+        for line in protein_lines:
+            if line.strip() == 'END':
+                # Create properly formatted TER card using the last atom's info
+                if last_atom_line and last_atom_line.startswith('ATOM'):
+                    # Extract atom number and residue info from last atom
+                    atom_num = last_atom_line[6:11].strip()
+                    res_name = last_atom_line[17:20].strip()
+                    chain_id = last_atom_line[21:22].strip()
+                    res_num = last_atom_line[22:26].strip()
+                    ter_line = f"TER    {atom_num:>5}      {res_name} {chain_id}{res_num}\n"
+                    protein_processed.append(ter_line)
+                else:
+                    protein_processed.append('TER\n')
+            else:
+                protein_processed.append(line)
+                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: protein + TER + ligand + END (no extra newline between TER and ligand)
+        merged_content = ''.join(protein_processed) + ''.join(ligand_processed) + 'END\n'
+        
+        with open(output_file, 'w') as f:
+            f.write(merged_content)
+        
+        return True
+    except Exception as e:
+        print(f"Error merging files: {str(e)}")
+        return False
+
+def prepare_structure(pdb_content, options, output_dir="output"):
+    """Main function to prepare structure for AMBER simulation"""
+    try:
+        # Create output directory if it doesn't exist
+        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")
+        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")
+        ligand_file = os.path.join(output_dir, "3_ligands_extracted.pdb")
+        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.5: Extract user-selected chains and ligands
+        selected_chains = options.get('selected_chains', [])
+        selected_ligands = options.get('selected_ligands', [])
+        
+        if selected_chains:
+            print(f"Step 0.5a: Extracting selected chains: {', '.join(selected_chains)}")
+            if not extract_selected_chains(pdb_content, user_chain_file, selected_chains):
+                raise Exception("Failed to extract selected chains")
+        else:
+            print("Step 0.5a: No chains selected, using original structure")
+            shutil.copy2(input_file, user_chain_file)
+        
+        if selected_ligands:
+            ligand_names = [f"{l.get('resn', '')}-{l.get('chain', '')}" for l in selected_ligands]
+            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")
+        else:
+            print("Step 0.5b: No ligands selected, creating empty ligand file")
+            with open(ligand_file, 'w') as f:
+                f.write('\n')
+        
+        # Step 1: Extract protein only (remove hydrogens) from user-selected chains
+        print("Step 1: Extracting protein without hydrogens from selected chains...")
+        # Read the user-selected chain file
+        with open(user_chain_file, 'r') as f:
+            chain_content = f.read()
+        
+        if not extract_protein_only(chain_content, protein_file):
+            raise Exception("Failed to extract protein")
+        
+        # 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)
+        
+        if add_ace or add_nme:
+            print("Step 2: Adding ACE and NME capping groups...")
+            if not add_capping_groups(protein_file, protein_capped_file):
+                raise Exception("Failed to add capping groups")
+        else:
+            print("Step 2: Skipping capping groups (add_ace=False, add_nme=False)")
+            print("Using protein without capping - copying to capped file")
+            # Copy protein file to capped file (no capping)
+            shutil.copy2(protein_file, protein_capped_file)
+        
+        # Step 3: Handle ligands (use pre-extracted ligand file)
+        preserve_ligands = options.get('preserve_ligands', True)
+        ligand_present = False
+        
+        if preserve_ligands:
+            print("Step 3: Processing pre-extracted ligands...")
+            
+            # Check if ligand file has content (not just empty or newline)
+            with open(ligand_file, 'r') as f:
+                ligand_content = f.read().strip()
+            
+            if ligand_content and len(ligand_content) > 1:
+                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
+                    }
+                
+                # 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")
+            else:
+                print("No ligands found in pre-extracted file, using protein only")
+                # Copy protein file to tleap_ready
+                shutil.copy2(protein_capped_file, tleap_ready_file)
+        else:
+            print("Step 3: Skipping ligand processing (preserve_ligands=False)")
+            print("Using protein only - copying capped protein to tleap_ready")
+            # Copy protein file to tleap_ready (protein only, no ligands)
+            shutil.copy2(protein_capped_file, tleap_ready_file)
+        
+        # Remove CONNECT records from tleap_ready.pdb (PyMOL adds them)
+        print("Removing CONNECT records from tleap_ready.pdb...")
+        remove_connect_records(tleap_ready_file)
+        
+        # Read the final prepared structure
+        with open(tleap_ready_file, 'r') as f:
+            prepared_content = f.read()
+            
+            # Calculate statistics
+            original_atoms = len([line for line in pdb_content.split('\n') if line.startswith('ATOM')])
+            prepared_atoms = len([line for line in prepared_content.split('\n') if line.startswith('ATOM')])
+            
+            # Calculate removed components
+            water_count = len([line for line in pdb_content.split('\n') if line.startswith('HETATM') and line[17:20].strip() in ['HOH', 'WAT', 'TIP3', 'TIP4', 'TIP5', 'SPC', 'SPCE']])
+            ion_count = len([line for line in pdb_content.split('\n') if line.startswith('HETATM') and line[17:20].strip() in ['NA', 'CL', 'K', 'MG', 'CA', 'ZN', 'FE', 'MN', 'CU', 'NI', 'CO', 'CD', 'HG', 'PB', 'SR', 'BA', 'RB', 'CS', 'LI', 'F', 'BR', 'I', 'PO4', 'PO3', 'H2PO4', 'HPO4', 'H3PO4']])
+            hydrogen_count = len([line for line in pdb_content.split('\n') if line.startswith('ATOM') and line[76:78].strip() == 'H'])
+            
+            # If not preserving ligands, count them as removed
+            ligand_count = 0
+            if not preserve_ligands and ligand_present:
+                # Count ligands from the pre-extracted file
+                with open(ligand_file, 'r') as f:
+                    ligand_lines = [line for line in f if line.startswith('HETATM')]
+                ligand_count = len(set(line[17:20].strip() for line in ligand_lines))
+            
+            removed_components = {
+                'water': water_count,
+                'ions': ion_count,
+                'hydrogens': hydrogen_count,
+                'ligands': ligand_count
+            }
+            
+            # Calculate added capping groups (only if capping was performed)
+            if add_ace or add_nme:
+                # Count unique ACE and NME residues, not individual atoms
+                ace_residues = set()
+                nme_residues = set()
+                
+                for line in prepared_content.split('\n'):
+                    if line.startswith('ATOM') and 'ACE' in line:
+                        # Extract residue number to count unique ACE groups
+                        res_num = line[22:26].strip()
+                        ace_residues.add(res_num)
+                    elif line.startswith('ATOM') and 'NME' in line:
+                        # Extract residue number to count unique NME groups
+                        res_num = line[22:26].strip()
+                        nme_residues.add(res_num)
+                
+                added_capping = {
+                    'ace_groups': len(ace_residues),
+                    'nme_groups': len(nme_residues)
+                }
+            else:
+                added_capping = {
+                    'ace_groups': 0,
+                    '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))
+            
+            result = {
+                'prepared_structure': prepared_content,
+                'original_atoms': original_atoms,
+                'prepared_atoms': prepared_atoms,
+                'removed_components': removed_components,
+                'added_capping': added_capping,
+                'preserved_ligands': preserved_ligands,
+                'ligand_present': ligand_present,
+                'separate_ligands': options.get('separate_ligands', False)
+            }
+            
+            # If separate ligands is enabled and ligands are present, include ligand content
+            if ligand_present and options.get('separate_ligands', False):
+                with open(ligand_corrected_file, 'r') as f:
+                    result['ligand_content'] = f.read()
+            
+            return result
+        
+    except Exception as e:
+        return {
+            'error': str(e),
+            'prepared_structure': '',
+            'original_atoms': 0,
+            'prepared_atoms': 0,
+            'removed_components': {},
+            'added_capping': {},
+            'preserved_ligands': 0,
+            'ligand_present': False
+        }
+
+def parse_structure_info(pdb_content):
+    """Parse structure information for display"""
+    lines = pdb_content.split('\n')
+    atom_count = 0
+    chains = set()
+    residues = set()
+    water_molecules = 0
+    ions = 0
+    ligands = set()
+    hetatoms = 0
+    
+    # Common water molecule names
+    water_names = {'HOH', 'WAT', 'TIP3', 'TIP4', 'SPC', 'SPCE'}
+    
+    # Common ion names
+    ion_names = {'NA', 'CL', 'K', 'MG', 'CA', 'ZN', 'FE', 'MN', 'CU', 'NI', 'CO', 'CD', 'HG', 'PB', 'SR', 'BA', 'RB', 'CS', 'LI', 'F', 'BR', 'I', 'PO4', 'PO3', 'H2PO4', 'HPO4', 'H3PO4','SO4'}
+    
+    # Common ligand indicators
+    ligand_indicators = {'ATP', 'ADP', 'AMP', 'GDP', 'GTP', 'NAD', 'FAD', 'HEM', 'HEME', 'COA', 'SAM', 'PLP', 'THF', 'FMN', 'FAD', 'NADP', 'UDP', 'CDP', 'TDP', 'GDP', 'ADP', 'ATP'}
+
+    for line in lines:
+        if line.startswith('ATOM'):
+            atom_count += 1
+            chain_id = line[21:22].strip()
+            if chain_id:
+                chains.add(chain_id)
+            
+            res_name = line[17:20].strip()
+            res_num = line[22:26].strip()
+            residues.add(f"{res_name}{res_num}")
+        elif line.startswith('HETATM'):
+            hetatoms += 1
+            res_name = line[17:20].strip()
+            
+            if res_name in water_names:
+                water_molecules += 1
+            elif res_name in ion_names:
+                ions += 1
+            elif res_name in ligand_indicators:
+                ligands.add(res_name)
+
+    # Count unique water molecules
+    unique_water_residues = set()
+    for line in lines:
+        if line.startswith('HETATM'):
+            res_name = line[17:20].strip()
+            res_num = line[22:26].strip()
+            if res_name in water_names:
+                unique_water_residues.add(f"{res_name}{res_num}")
+
+    return {
+        'atom_count': atom_count,
+        'chains': list(chains),
+        'residue_count': len(residues),
+        'water_molecules': len(unique_water_residues),
+        'ions': ions,
+        'ligands': list(ligands),
+        'hetatoms': hetatoms
+    }
+
+def test_structure_preparation():
+    """Test function to verify structure preparation works correctly"""
+    # Create a simple test PDB content
+    test_pdb = """HEADER    TEST PROTEIN
+ATOM      1  N   MET A   1      16.347  37.019  21.335  1.00 50.73           N  
+ATOM      2  CA  MET A   1      15.737  37.120  20.027  1.00 45.30           C  
+ATOM      3  C   MET A   1      15.955  35.698  19.546  1.00 41.78           C  
+ATOM      4  O   MET A   1      16.847  35.123  20.123  1.00 40.15           O  
+ATOM      5  CB  MET A   1      14.234  37.456  19.789  1.00 44.12           C  
+ATOM      6  CG  MET A   1      13.456  36.123  19.234  1.00 43.45           C  
+ATOM      7  SD  MET A   1      12.123  35.456  18.123  1.00 42.78           S  
+ATOM      8  CE  MET A   1      11.456  34.123  17.456  1.00 42.11           C  
+ATOM      9  N   ALA A   2      15.123  35.456  18.789  1.00 40.44           N  
+ATOM     10  CA  ALA A   2      14.456  34.123  18.123  1.00 39.77           C  
+ATOM     11  C   ALA A   2      13.123  33.456  17.456  1.00 39.10           C  
+ATOM     12  O   ALA A   2      12.456  32.123  16.789  1.00 38.43           O  
+ATOM     13  CB  ALA A   2      13.789  33.123  17.123  1.00 38.76           C  
+ATOM     14  N   ALA A   3      12.789  32.456  16.123  1.00 38.09           N  
+ATOM     15  CA  ALA A   3      11.456  31.789  15.456  1.00 37.42           C  
+ATOM     16  C   ALA A   3      10.123  30.456  14.789  1.00 36.75           C  
+ATOM     17  O   ALA A   3       9.456  29.123  14.123  1.00 36.08           O  
+ATOM     18  CB  ALA A   3       9.789  29.456  13.456  1.00 35.41           C  
+ATOM     19  OXT ALA A   3       8.123  28.789  13.456  1.00 35.74           O  
+HETATM   20  O   HOH A   4      20.000  20.000  20.000  1.00 20.00           O  
+HETATM   21  H1  HOH A   4      20.500  20.500  20.500  1.00 20.00           H  
+HETATM   22  H2  HOH A   4      19.500  19.500  19.500  1.00 20.00           H  
+HETATM   23  NA  NA  A   5      25.000  25.000  25.000  1.00 25.00          NA  
+HETATM   24  CL  CL  A   6      30.000  30.000  30.000  1.00 30.00          CL  
+HETATM    1  PG  GTP A 180      29.710  30.132  -5.989  1.00 52.48      A    P  
+HETATM    2  O1G GTP A 180      29.197  28.937  -5.265  1.00 43.51      A    O  
+HETATM    3  O2G GTP A 180      30.881  29.816  -6.827  1.00 63.11      A    O  
+HETATM    4  O3G GTP A 180      30.013  31.278  -5.117  1.00 29.97      A    O  
+HETATM    5  O3B GTP A 180      28.517  30.631  -6.995  1.00 23.23      A    O  
+HETATM    6  PB  GTP A 180      27.017  31.171  -6.766  1.00 29.58      A    P  
+HETATM    7  O1B GTP A 180      26.072  30.050  -6.958  1.00 17.62      A    O  
+HETATM    8  O2B GTP A 180      26.960  31.913  -5.483  1.00 38.76      A    O  
+HETATM    9  O3A GTP A 180      26.807  32.212  -7.961  1.00 13.12      A    O  
+HETATM   10  PA  GTP A 180      26.277  33.726  -8.045  1.00 25.06      A    P  
+HETATM   11  O1A GTP A 180      25.089  33.867  -7.187  1.00 44.06      A    O  
+HETATM   12  O2A GTP A 180      27.427  34.635  -7.843  1.00 23.47      A    O  
+HETATM   13  O5' GTP A 180      25.804  33.834  -9.555  1.00 42.05      A    O  
+HETATM   14  C5' GTP A 180      26.615  33.475 -10.679  1.00 19.97      A    C  
+HETATM   15  C4' GTP A 180      26.219  34.288 -11.894  1.00 14.90      A    C  
+HETATM   16  O4' GTP A 180      24.826  34.017 -12.143  1.00 19.00      A    O  
+HETATM   17  C3' GTP A 180      26.372  35.802 -11.724  1.00  4.96      A    C  
+HETATM   18  O3' GTP A 180      26.880  36.347 -12.936  1.00 44.49      A    O  
+HETATM   19  C2' GTP A 180      24.932  36.243 -11.481  1.00 17.12      A    C  
+HETATM   20  O2' GTP A 180      24.719  37.581 -11.901  1.00 32.45      A    O  
+HETATM   21  C1' GTP A 180      24.069  35.240 -12.240  1.00 16.17      A    C  
+HETATM   22  N9  GTP A 180      22.724  35.005 -11.630  1.00 28.10      A    N  
+HETATM   23  C8  GTP A 180      22.443  34.655 -10.325  1.00 27.05      A    C  
+HETATM   24  N7  GTP A 180      21.168  34.483 -10.079  1.00 33.25      A    N  
+HETATM   25  C5  GTP A 180      20.554  34.737 -11.307  1.00 26.23      A    C  
+HETATM   26  C6  GTP A 180      19.183  34.712 -11.659  1.00 29.31      A    C  
+HETATM   27  O6  GTP A 180      18.205  34.448 -10.957  1.00 40.80      A    O  
+HETATM   28  N1  GTP A 180      19.000  35.036 -13.013  1.00 26.85      A    N  
+HETATM   29  C2  GTP A 180      20.022  35.339 -13.903  1.00 28.70      A    C  
+HETATM   30  N2  GTP A 180      19.627  35.619 -15.147  1.00 44.24      A    N  
+HETATM   31  N3  GTP A 180      21.301  35.367 -13.569  1.00 21.67      A    N  
+HETATM   32  C4  GTP A 180      21.489  35.054 -12.257  1.00 41.91      A    C  
+END
+"""
+    
+    options = {
+        'remove_water': True,
+        'remove_ions': True,
+        'remove_hydrogens': True,
+        'add_ace': True,
+        'add_nme': True,
+        'preserve_ligands': True,
+        'separate_ligands': False,
+        'fix_missing_atoms': False,
+        'standardize_residues': False
+    }
+    
+    print("Testing structure preparation...")
+    result = prepare_structure(test_pdb, options, "output")
+    
+    print("\n=== STATISTICS ===")
+    print(f"Original atoms: {result['original_atoms']}")
+    print(f"Prepared atoms: {result['prepared_atoms']}")
+    print(f"Removed: {result['removed_components']}")
+    print(f"Added: {result['added_capping']}")
+    print(f"Ligands: {result['preserved_ligands']}")
+    print(f"Ligand present: {result['ligand_present']}")
+    
+    print(f"\nTest completed! Check 'output' folder for results:")
+    print("- 1_protein_no_hydrogens.pdb (protein without hydrogens)")
+    print("- 2_protein_with_caps.pdb (protein with ACE/NME caps)")
+    print("- 3_ligands_extracted.pdb (extracted ligands, if any)")
+    print("- 4_ligands_corrected.pdb (corrected ligands, if any)")
+    print("- tleap_ready.pdb (final structure ready for tleap)")
+
+if __name__ == "__main__":
+    test_structure_preparation()

start_web_server.py

@@ -0,0 +1,20 @@
+#!/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
+"""
+
+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
+
+if __name__ == "__main__":
+    # Run the Flask app
+    app.run(debug=False, host='0.0.0.0', port=7860)