### Install and Configure iPBSA (Bash)

Source: https://context7.com/sahakyanhk/ipbsa/llms.txt

Installs iPBSA by downloading, extracting, and making the main script executable. It then adds the script's directory to the system's PATH for global access. Finally, it verifies the installation by running the script without arguments.

```bash
# Download and extract iPBSA
wget https://github.com/sahakyanhk/iPBSA/archive/refs/heads/main.zip
unzip main.zip
chmod +x iPBSA-main/iPBSA.sh

# Add to PATH for global access
export PATH=$(pwd)/iPBSA-main/:$PATH

# Verify installation
iPBSA.sh
```

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

### MM/PBSA Binding Free Energy Calculation Setup and Execution

Source: https://context7.com/sahakyanhk/ipbsa/llms.txt

Sets up and runs a Molecular Mechanics/Poisson-Boltzmann Surface Area (MM/PBSA) calculation for binding free energy. It involves creating an input file 'pbsa.in' with general and PB parameters, then executing the MMPBSA.py script with specified input and output files, topology, and restart files. The script handles various simulation parameters like frame selection, solvent stripping, and ionic strength.

```bash
# Create PBSA input file
cat > pbsa.in <<EOF
mmgbsa  analysis
&general
startframe=1, interval=1, endframe=9999,
verbose=2, keep_files=0, netcdf=1,
strip_mask = ":WAT,Cl-,Na+,K+",
/
&pb
inp=1
istrng=0.150
/
EOF

# Run MM/PBSA calculation
MMPBSA.py -O -i pbsa.in \
    -o  FINAL_RESULTS_pbsa_ligand_001.dat \
    -eo en_pre-frames_ligand_001.dat \
    -cp parm/complex_ligand_001.prmtop \
    -rp parm/protein.prmtop \
    -lp parm/ligand_001.prmtop \
    -y  min/min_ligand_001.rst
```

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

### Download and Export iPBSA Script (Bash)

Source: https://github.com/sahakyanhk/ipbsa/blob/main/README.md

This snippet demonstrates how to download, unzip, make executable, and export the iPBSA script to your PATH. It requires `wget` and `unzip` to be installed.

```bash
wget https://github.com/sahakyanhk/iPBSA/archive/refs/heads/main.zip; unzip main.zip; chmod +x iPBSA-main/iPBSA.sh
export PATH=$(pwd)/iPBSA-main/:$PATH
```

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

### Extract Binding Energy using sed and awk

Source: https://context7.com/sahakyanhk/ipbsa/llms.txt

Extracts the binding energy value from a data file by filtering lines before 'DELTA TOTAL' and selecting the last field delimited by commas. This is commonly used after molecular dynamics simulations to get a specific energy contribution. It assumes a specific file format. The output is appended to FINAL_GBSA.dat.

```bash
GB=$(sed -e '1,/DELTA TOTAL/d' en_pre-frames_ligand_001.dat | awk -F ',' '{print $NF}' | head -n 1)
echo "ligand_001 $GB" >> FINAL_GBSA.dat
```

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

### Prepare Receptor-Ligand Complex with tLEaP (Bash)

Source: https://context7.com/sahakyanhk/ipbsa/llms.txt

Creates AMBER topology (.prmtop) and coordinate (.inpcrd) files for receptor-ligand complexes using the tLEaP program. It sources AMBER and GAFF force fields, loads the receptor and ligand parameters, combines them, and saves the complex files. Input is provided via a here-document.

```bash
# Create tLEaP input file
cat > xtleap.in <<EOF
source leaprc.protein.ff14SB
source leaprc.gaff
set default PBradii mbondi3
PROT=loadpdb parm/rec.pdb
LIG=loadmol2 parm/ligand_001.mol2
loadamberparams parm/ligand_001.frcmod
complex = combine {PROT LIG}
saveamberparm complex parm/complex_ligand_001.prmtop parm/complex_ligand_001.inpcrd
saveamberparm LIG parm/ligand_001.prmtop parm/ligand_001.inpcrd
quit
EOF

# Execute tLEaP
tleap -f xtleap.in > tleap.log
```

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

### Prepare Receptor with pdb4amber (Bash)

Source: https://context7.com/sahakyanhk/ipbsa/llms.txt

Prepares a receptor PDB file for AMBER compatibility by removing hydrogens and crystallographic water molecules. Outputs a cleaned PDB file suitable for downstream parameterization. It handles hydrogen addition, water removal, and PDB formatting.

```bash
# Input: raw PDB file from crystallography
# Output: cleaned receptor ready for parameterization
mkdir -p output/parm
pdb4amber -i receptor.pdb -o output/parm/rec.pdb --nohyd --dry

# The script automatically handles:
# - Hydrogen removal (--nohyd)
# - Water molecule removal (--dry)
# - PDB formatting for AMBER compatibility
```

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

### Run iPBSA Docking Rescoring Pipeline (Bash)

Source: https://context7.com/sahakyanhk/ipbsa/llms.txt

Executes the iPBSA docking rescoring pipeline. Requires receptor structure and a directory of ligands. Outputs results to a specified directory. Supports various parameters for customization, including charge method and thread count.

```bash
# Basic usage with default parameters
./iPBSA.sh -r receptor.pdb -l ligand_directory/ -o output_results

# Advanced usage with all parameters
./iPBSA.sh -r protein/2b8t-A.pdb -l ligands/ -n 10 -c bcc -o test_output

# Using GAS charge method with custom thread count
./iPBSA.sh -r CORE/5t2p.pdb -l CORE/lig_dir/ -c gas -n 8 -o core_results
```

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

### Parameterize Ligands with Antechamber (Bash)

Source: https://context7.com/sahakyanhk/ipbsa/llms.txt

Generates GAFF force field parameters and AM1-BCC charges for small molecules (ligands). This bash script iterates through multiple PDB ligand files, creating mol2 and frcmod files necessary for AMBER simulations. It supports parallel processing.

```bash
# Parallel processing of multiple ligands
cd parm
for lig in ../mols/*.pdb; do
    mol=$(basename $lig .pdb)
    mkdir -p $mol
    cd $mol

    # Generate mol2 file with charges
    antechamber -i ../../mols/${mol}.pdb \
                -fi pdb \
                -o $mol.mol2 \
                -fo mol2 \
                -at gaff \
                -c bcc \
                -rn UNL \
                -nc 0

    # Generate force field modification file
    parmchk2 -i ${mol}.mol2 -f mol2 -o ${mol}.frcmod

    cd ..
done
```

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

### Calculate Binding Free Energy with MM/GBSA (Bash)

Source: https://context7.com/sahakyanhk/ipbsa/llms.txt

Calculates binding free energy using the MM/GBSA method with MMPBSA.py. This script sets up the input file for the calculation, specifying general parameters, GB model settings, salt concentration, and stripping mask. It then executes the calculation using provided topology, receptor, ligand, and minimized coordinate files.

```bash
# Create GBSA input file
cat > gbsa.in <<EOF
mmgbsa  analysis
&general
startframe=1, interval=1, endframe=9999,
verbose=2, keep_files=0, netcdf=1,
strip_mask = ":WAT,Cl-,Na+,K+",
/
&gb
igb=2,
saltcon=0.150,
/
EOF

# Run MM/GBSA calculation
MMPBSA.py -O -i gbsa.in \
    -o  FINAL_RESULTS_GBSA_ligand_001.dat \
    -eo en_pre-frames_ligand_001.dat \
    -cp parm/complex_ligand_001.prmtop \
    -rp parm/protein.prmtop \
    -lp parm/ligand_001.prmtop \
    -y  min/min_ligand_001.rst
```

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

### Run iPBSA Script (Bash)

Source: https://github.com/sahakyanhk/ipbsa/blob/main/README.md

This snippet shows the basic command to execute the iPBSA script. It requires a receptor PDB file, a directory of ligand PDB files, the number of parallel threads, a charge method, and an output directory.

```bash
./iPBSA.sh -r <receptor.pdb> -l <ligand_directory> -n <num_threads> -c <bcc/gas> -o <output_directory>
```

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

### iPBSA Workflow for CORE Protein

Source: https://context7.com/sahakyanhk/ipbsa/llms.txt

Runs a complete iPBSA workflow for the CORE protein with docked ligands. It specifies the receptor PDB, ligand directory, charge calculation method, number of parallel threads, and output directory. The script generates logs for each stage of the process (antechamber, parmchk2, preparation, minimization, GBSA, PBSA) and demonstrates how to monitor progress using 'tail -f' and analyze final results by sorting PBSA data.

```bash
# Run complete pipeline for CORE protein
iPBSA.sh -r CORE/5t2p.pdb \
         -l CORE/lig_dir/ \
         -c bcc \
         -n 8 \
         -o test_out_core

# Processing stages logged to separate files:
# - antechamber.log     # Ligand charge calculation
# - parmchk2.log        # Force field parameter generation
# - prot_tleap.log      # Receptor preparation
# - tleap.log           # Complex preparation
# - minimization.log    # Energy minimization
# - gbsa.log            # GBSA calculations
# - pbsa.log            # PBSA calculations

# Monitor progress in real-time
tail -f test_out_core/minimization.log

# Analyze final results
sort -k2 -n test_out_core/FINAL_PBSA.dat | head -5
# Shows top 5 compounds with strongest binding affinity
```

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

### Minimize Complex with SANDER (Bash)

Source: https://context7.com/sahakyanhk/ipbsa/llms.txt

Performs constrained energy minimization on receptor-ligand complexes in an implicit solvent using the SANDER program. The input file defines minimization parameters like maximum cycles, cutoff, and restraint settings. The output is a minimized coordinate file.

```bash
# Create minimization input file
cat > min.in <<EOF
Initial minimisation of rec-lig complex
&cntrl
 imin=1,
maxcyc=2500, ncyc=100,
cut=16, ntb=0, igb=0,
ntpr=500,
ntwx=500,
ntwr=500
drms=0.01
ibelly=1,
bellymask=':UNL <@5'
&end
EOF

# Run minimization
sander -O -i min.in \
       -p parm/complex_ligand_001.prmtop \
       -c parm/complex_ligand_001.inpcrd \
       -r min/min_ligand_001.rst \
       -ref parm/complex_ligand_001.inpcrd \
       -o min/minim_ligand_001.out

# Output: minimized structure in min/min_ligand_001.rst
```

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

### iPBSA Workflow for KITH Protein

Source: https://context7.com/sahakyanhk/ipbsa/llms.txt

Executes a complete iPBSA workflow for the KITH protein system, processing multiple ligands. It uses the 'iPBSA.sh' script with specified receptor PDB, ligand directory, number of parallel threads, charge calculation method, and output directory. The script handles topology generation, minimization, GBSA, and PBSA calculations. It also shows how to view the final ranked GBSA results.

```bash
# Navigate to examples directory
cd iPBSA-main/examples

# Run complete pipeline for KITH protein
iPBSA.sh -r KITH/2b8t-A.pdb \
         -l KITH/ligands/ \
         -n 10 \
         -c bcc \
         -o test_out_kith

# Expected output structure:
# test_out_kith/
# ├── FINAL_GBSA.dat          # Ranked GBSA results
# ├── FINAL_PBSA.dat          # Ranked PBSA results
# ├── parm/                   # Topology files
# │   ├── rec.pdb
# │   ├── protein.prmtop
# │   └── complex_*.prmtop
# ├── min/                    # Minimized structures
# │   └── min_*.rst
# ├── gbsa/                   # GBSA calculations
# │   └── FINAL_RESULTS_GBSA_*.dat
# └── pbsa/                   # PBSA calculations
#     └── FINAL_RESULTS_pbsa_*.dat

# View results
cat test_out_kith/FINAL_GBSA.dat
# Expected format:
# KITH_1110 -42.5
# KITH_1115 -38.2
# KITH_1112 -35.7
# ...
```

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

### Parallel Ligand Processing with Job Control

Source: https://context7.com/sahakyanhk/ipbsa/llms.txt

Processes multiple ligands concurrently using shell job control. It iterates through PDB files in the './mols/' directory, launches an antechamber command for each ligand in a subshell, and limits the number of simultaneously running jobs to 'N' using 'jobs -r -p' and 'wait -n'. This workflow helps accelerate the preparation of multiple ligand files.

```bash
# Set number of parallel threads
N=10

# Process ligands in parallel with job control
for lig in ./mols/*.pdb; do
    (
        mol=$(basename $lig .pdb)
        # Processing commands here
        antechamber -i mols/${mol}.pdb -fi pdb -o parm/${mol}/${mol}.mol2 -fo mol2 -at gaff -c bcc -rn UNL -nc 0
        sleep $((RANDOM % 3 + 1))
    ) &

    # Limit concurrent jobs to N
    if [[ $(jobs -r -p | wc -l) -ge $N ]]; then
        wait -n
    fi
done

# Wait for all jobs to complete
wait
```

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

### Extract and Sort Binding Energies for GBSA and PBSA

Source: https://context7.com/sahakyanhk/ipbsa/llms.txt

Iterates through ligand PDB files, extracts GBSA and PBSA binding energies using 'sed' and 'awk', and saves them to 'rawGBSA.dat' and 'rawPBSA.dat' respectively. Finally, it sorts these raw energy files numerically and outputs the top-ranked results to 'FINAL_GBSA.dat' and 'FINAL_PBSA.dat', displaying the top 10 GBSA results.

```bash
# Extract binding energies from all ligands
for lig in ./mols/*.pdb; do
    mol=$(basename $lig .pdb)

    # Extract GBSA energy
    GB=$(sed -e '1,/DELTA TOTAL/d' gbsa/en_pre-frames_${mol}.dat | \
         awk -F ',' '{print $NF}' | head -n 1)
    echo "$mol $GB" >> rawGBSA.dat

    # Extract PBSA energy
    PB=$(sed -e '1,/DELTA TOTAL/d' pbsa/en_pre-frames_${mol}.dat | \
         awk -F ',' '{print $NF}' | head -n 1)
    echo "$mol $PB" >> rawPBSA.dat
done

# Sort results by binding energy (most negative = strongest binding)
sort -V rawGBSA.dat | grep ' ' > FINAL_GBSA.dat
sort -V rawPBSA.dat | grep ' ' > FINAL_PBSA.dat

# View top-ranked compounds
head -10 FINAL_GBSA.dat
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.