### Install CADEE

Source: https://github.com/kamerlinlab/cadee/blob/master/doc/example_installation_uppmax_rackham.md

Clone the CADEE repository, navigate to its directory, and install it using the setup.py script with the --user flag.

```bash
cd $HOME
cd Downloads
git clone https://github.com/kamerlinlab/cadee cadee
cd cadee
python setup.py install --user
```

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

### CADEE Usage Example

Source: https://github.com/kamerlinlab/cadee/blob/master/doc/example_installation_uppmax_rackham.md

Example output showing the basic usage of CADEE, including multi-core task commands.

```text
Usage:
                   cadee [ prep(p) | dyn(d) | ana(a) | tool(t) ]

       Multi Core Tasks:
                    mpirun -n X cadee dyn
                   mpiexec -n X cadee dyn
                   X == Number of cores to use; 2+.
```

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

### Install CADEE package

Source: https://github.com/kamerlinlab/cadee/blob/master/readme.md

Install the CADEE package after cloning the repository. The --user flag installs it for the current user.

```bash
python setup.py install --user
```

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

### Load Modules for CADEE Installation

Source: https://github.com/kamerlinlab/cadee/blob/master/doc/example_installation_uppmax_rackham.md

Load the required Intel, MPI, and Open Babel modules before proceeding with the installation.

```bash
module add intel/17.4 intelmpi/17.4 openbabel
```

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

### Installing CADEE

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Provides instructions for installing CADEE, including prerequisite packages and cloning the repository. It also details how to ensure Q6 binaries are accessible.

```bash
# Prerequisites: Python 2.7, gfortran, gcc, OpenMPI, Open Babel, SCWRL4, Q6
sudo apt-get install gfortran gcc openmpi-bin mpich git openbabel python-pip

# Clone and install
git clone https://github.com/kamerlinlab/cadee cadee
cd cadee
python setup.py install --user

# Q6 binaries (Qdyn6, Qprep6, Qfep6, Qcalc6) must be in $PATH or in
# cadee/executables/q/ — setup.py will prompt to copy them automatically.

# Verify installation
cadee --help
```

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

### Install SCWRL4 and Verify PATH

Source: https://github.com/kamerlinlab/cadee/blob/master/doc/example_installation_uppmax_rackham.md

Install the SCWRL4 executable to $HOME/.local/bin/ and confirm it is accessible via the system's PATH.

```bash
which Scwrl4
> ~/.local/bin/Scwrl4
```

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

### Install CADEE using Git

Source: https://github.com/kamerlinlab/cadee/blob/master/readme.md

Clone the CADEE repository using git to easily access future releases. This is the recommended installation method.

```bash
git clone https://github.com/kamerlinlab/cadee cadee
```

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

### Install mpi4py 1.3.1

Source: https://github.com/kamerlinlab/cadee/blob/master/INSTALL.md

Installs mpi4py 1.3.1 after downloading the source. This process involves extracting the archive, changing directory, and running the setup script. It may require loading specific compiler modules.

```bash
tar xf mpi4py-1.3.1.tar.gz
cd mpi4py-1.3.1
tar xf python setup.py install --user
```

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

### Install CADEE locally

Source: https://github.com/kamerlinlab/cadee/blob/master/INSTALL.md

Installs CADEE for the current user after cloning the repository. This command should be run from within the cloned CADEE directory.

```bash
cd $HOME/Downloads/cadee
python setup.py install --user
```

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

### Install System Dependencies on Debian/Ubuntu

Source: https://github.com/kamerlinlab/cadee/blob/master/INSTALL.md

Installs necessary compilers and tools for CADEE using apt-get. Ensure your system is compatible with these packages.

```bash
sudo apt-get install gfortran gcc openmpi-bin mpich git openbabel python-pip
```

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

### Verify CADEE Installation

Source: https://github.com/kamerlinlab/cadee/blob/master/doc/example_installation_uppmax_rackham.md

Check if the CADEE executable is correctly installed and available in the system's PATH.

```bash
which cadee
> ~/.local/bin/cadee
```

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

### Download and Compile Open Babel

Source: https://github.com/kamerlinlab/cadee/blob/master/doc/example_installation_hpc2n_abisko.md

Download, extract, compile, and install Open Babel from source. The binaries are then added to the PATH.

```bash
cd ~/
pfs
wget  https://sourceforge.net/projects/openbabel/files/openbabel/2.4.1/openbabel-2.4.1.tar.gz
tar xf openbabel-2.4.1.tar.gz 
cd openbabel-2.4.1/
mkdir build
cd build
cmake ../
make
cd bin
```

```bash
echo export PATH="$PWD:\$PATH" >> ~/.bashrc
source ~/.bashrc
```

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

### Download mpi4py 1.3.1

Source: https://github.com/kamerlinlab/cadee/blob/master/INSTALL.md

Downloads the mpi4py 1.3.1 source archive using wget. This is a troubleshooting step for manual mpi4py installation.

```bash
wget -O mpi4py-1.3.1.tar.gz https://pypi.python.org/packages/26/b4/1a9678ec113b5c654477354169131c88be3f65e665d7de7c5ef306f2f2a5/mpi4py-1.3.1.tar.gz
```

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

### Perform Combinatorial Multi-Point Mutations

Source: https://github.com/kamerlinlab/cadee/blob/master/workflow.md

Demonstrates combinatorial multi-point mutations. This example mutates residues 137 and 138 to 'DEKCPG' and residue 139 to SATURATE.

```bash
cadee prep wt.pdb wt.fep qprep6.inp ./libraries --libmut 137:'DEKCPG' 138:'DEKCPG' 139:SATURATE
```

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

### Perform Saturation Mutation

Source: https://github.com/kamerlinlab/cadee/blob/master/workflow.md

Performs a saturation mutation at a specified residue. This example saturates residue 15.

```bash
cadee prep wt.pdb wt.fep qprep6.inp ./libraries --libmut 15:SATURATE
```

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

### Generate Arbitrary Mutation Inputs with SCWRL4

Source: https://github.com/kamerlinlab/cadee/blob/master/INSTALL.md

Uses SCWRL4 to generate input files for arbitrary mutations, such as changing residue 15 to Glutamic acid. Requires SCWRL4 to be installed and in the PATH.

```bash
./cadee.py wt.pdb wt.fep qprep5.ipn ./libraries --libmut 15:E
```

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

### Perform Single Point Library Mutation

Source: https://github.com/kamerlinlab/cadee/blob/master/workflow.md

Performs arbitrary mutations using SCWRL4. This example mutates residue 15 to glutamic acid.

```bash
cadee prep wt.pdb wt.fep qprep5.ipn ./libraries --libmut 15:E
```

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

### Generate Saturation Mutagenesis Inputs with SCWRL4

Source: https://github.com/kamerlinlab/cadee/blob/master/INSTALL.md

Generates input files for a saturation mutagenesis at a specified residue using SCWRL4. Requires SCWRL4 to be installed and in the PATH.

```bash
./cadee.py wt.pdb wt.fep qprep5.ipn ./libraries --libmut 15:SATURATE
```

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

### Launch CADEE with MPI

Source: https://github.com/kamerlinlab/cadee/blob/master/doc/example_installation_hpc2n_abisko.md

Demonstrates how to launch CADEE using mpiexec or srun, ensuring the intelmpi library is loaded.

```bash
module add iimpi/2017b
cadee --help
mpiexec -n 1 $(which cadee) --help

or, when on a node:

srun -n 1 $HOME/.local/bin/cadee --help
```

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

### Launch CADEE with Intel MPI

Source: https://github.com/kamerlinlab/cadee/blob/master/doc/example_installation_uppmax_rackham.md

Load the Intel MPI library and launch CADEE with the --help flag. Alternatively, use srun on a compute node.

```bash
module add intelmpi/17.4
cadee --help

or, when on a node:

srun -n 1 $(which cadee) --help
srun -n 1 $HOME/.local/bin/cadee --help
```

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

### Prepare Wild-Type Reaction

Source: https://github.com/kamerlinlab/cadee/blob/master/workflow.md

Prepares the wild-type reaction using PDB, FEP, and Qprep input files. Ensure absolute paths are used for libraries.

```bash
cadee prep wt.pdb wt.fep qprep6.inp ./libraries
```

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

### Prepare library mutation with named amino acid groups using CADEE prep

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Utilize named amino acid group shortcuts like 'NEGATIVE', 'POLAR', 'UNCHARGED', 'HYDROPHOBIC', and 'SATURATE' with `cadee prep --libmut` for efficient library preparation.

```bash
cadee prep wt.pdb wt.fep qprep6.inp ./libraries \
    --libmut 15:NEGATIVE --numseeds 4
```

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

### Clone and Compile Q

Source: https://github.com/kamerlinlab/cadee/blob/master/doc/example_installation_hpc2n_abisko.md

Clone the Q source repository, checkout the development branch, compile it using ifort, and add its binaries to the PATH.

```bash
git clone https://github.com/qusers/qsource.git .
cd qsource
git checkout development/beat  # fix for 'make all'
cd src
make all COMP=ifort
cd ../bin
export PATH="$PWD:$PATH"
```

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

### Prepare single-point library mutation with CADEE prep

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Use `cadee prep` with `--libmut` to create simpacks for single-point mutations at a specific residue. 'SATURATE' mutates to all 20 standard amino acids.

```bash
cadee prep wt.pdb wt.fep qprep6.inp ./libraries \
    --libmut 137:SATURATE
```

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

### Generate Simulation Inputs

Source: https://github.com/kamerlinlab/cadee/blob/master/INSTALL.md

Initializes CADEE to generate simulation input files. Requires PDB, FEP, and qprep input files, along with a path to libraries.

```bash
./cadee.py wt.pdb wt.fep qprep5.inp ./libraries
```

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

### Scan Simulation Input Files

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Scans a simpack directory for Qdyn6 `.inp` files, determines the run order, and extracts simulation parameters like topology, FEP file, input files, total steps, and total simulated time. Used by `ensemble.Worker`.

```python
from cadee.dyn.scan import Scan
import os

os.chdir('/path/to/simpack_dir')
s = Scan()                  # scans current directory
topology, fepfile, inputfiles, total_steps, total_fs = s.scan()

print('Topology:', topology)          # e.g. 'mutant.top'
print('FEP file:', fepfile)           # e.g. 'mutant.fep'
print('Input files:', inputfiles[:3]) # e.g. ['0001_min.inp','0002_eq.inp',...]
print('Steps:', total_steps)          # e.g. 5000000
print('Sim time (fs):', total_fs)     # e.g. 10000000.0  (10 ns)

# Scan a specific directory
s2 = Scan('/path/to/another_simpack')
result = s2.scan()
```

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

### Clone and Compile Qsource

Source: https://github.com/kamerlinlab/cadee/blob/master/doc/example_installation_uppmax_rackham.md

Clone the qsource repository, checkout the development branch for a fix, compile the source code using ifort, and add the executables to the PATH.

```bash
git clone https://github.com/qusers/qsource.git .
git checkout development/beat  # fix for 'make all'
cd qsource/src/
make all COMP=ifort
cd ../bin
export PATH="$PWD:$PATH"
```

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

### Prepare combinatorial double mutation with CADEE prep

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Generate simpacks for combinatorial double mutations at specified residues using `cadee prep --libmut`. This allows for exploring combinations of mutations.

```bash
cadee prep wt.pdb wt.fep qprep6.inp ./libraries \
    --libmut 137:'DEKCPG' 138:'DEKCPG'
```

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

### Run ensemble MD simulation with on-the-fly EVB mapping

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Execute `cadee dyn` with on-the-fly EVB mapping by providing `--alpha` and `--hij` parameters. This is useful when alpha and Hij parameters are required together.

```bash
mpirun -n 8 cadee dyn ./ala_scan --alpha 0.5 --hij 10.0
```

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

### Using SqlDB to persist free-energy results

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Demonstrates how to open an SQLite database, create a Results object, add it to the database, and query results directly. The SqlDB buffers writes and auto-commits on a configurable interval.

```python
from cadee.dyn.tools import SqlDB, Results

# Open (or create) the database
db = SqlDB('cadee.db', interval=300)  # commit every 300 s

# Build a Results object and add it
res = Results(mutant='ARG15ALA', replik=0, name='1200_eq', feptype='us')
res.dg(barr=14.2, exo=-3.1)          # activation barrier and reaction free energy
res.temp(tot=300.1, free=299.8, free_solvent=300.0, free_solute=299.5)
res.ene(kin=1200.3, pot=-45000.1, tot=-43799.8)

db.add_row(res)   # buffered INSERT
db.flush()        # force commit now
db.close()        # final commit + close

# Query results directly with sqlite3
import sqlite3
conn = sqlite3.connect('cadee.db')
rows = conn.execute(
    "SELECT mutant, AVG(barr_forw), AVG(exo) FROM results "
    "WHERE feptype='us' GROUP BY mutant ORDER BY AVG(barr_forw))"
).fetchall()
for row in rows:
    print(row)
# ('wt',      12.1, -3.0)
# ('ARG15ALA', 14.2, -3.1)
# ...
conn.close()
```

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

### Download CADEE using Git

Source: https://github.com/kamerlinlab/cadee/blob/master/INSTALL.md

Clones the CADEE repository from GitHub into a 'Downloads' directory in your home folder. This method facilitates easy updates.

```bash
cd $HOME
mkdir -p Downloads
cd Downloads
git clone https://github.com/kamerlinlab/cadee cadee
```

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

### Run ensemble MD simulation with CADEE dyn

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Launch an MPI ensemble simulation using `cadee dyn`. Rank 0 distributes simpacks to workers, which run simulations and return results to rank 0 for storage in `cadee.db`.

```bash
mpirun -n 8 cadee dyn ./ala_scan
```

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

### Show top-level usage of CADEE CLI

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Run the `cadee` script without arguments to display its top-level usage instructions and available sub-commands.

```bash
cadee --help
```

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

### Perform alanine scan with CADEE prep

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Generate simpacks for an alanine scan of a protein. CADEE automatically determines the necessary mutation radius and creates mutant folders.

```bash
cadee prep wt.pdb wt.fep qprep6.inp ./libraries \
    --alascan --nummuts 16
```

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

### Using Results container for free energy data

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Shows how to create a Results object to aggregate free energy, temperature, and energy data for an MD simulation segment. The object can be printed for a summary or converted to a list for database insertion.

```python
from cadee.dyn.tools import Results

res = Results(mutant='LYS22ALA', replik=1, name='1400_prod', feptype='us')
res.dg(barr=13.5, exo=-2.8)
res.temp(tot=300.5, free=300.2, free_solvent=300.4, free_solute=299.9)
res.ene(kin=1195.0, pot=-44950.0, tot=-43755.0)

print(res)
# Time: 1700000000000, Name: 1400_prod, FepType: us
# dGa: 13.50 dG0: -2.80 dGa_rev: 16.30
# Temps: ttot: 300.5, free: 300.2, solv: 300.4, solu: 299.9
# Energies: Total: -43755.0, Potential: -44950.0, Kinetic: 1195.0

items = res.items()
# [timestamp, 'LYS22ALA', 1, '1400_prod', 'us',
#  13.5, -2.8, 16.3, 300.5, 300.2, 299.9, 300.4, 1195.0, -44950.0, -43755.0]
```

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

### Programmatic usage of alanize function

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Import and use the `main` function from `cadee.ana.alanize` in Python for programmatic generation of the interactive HTML visualization from `cadee.db`.

```python
from cadee.ana.alanize import main
main('cadee.db')
```

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

### scan.Scan — Q6 Input File Scanner

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Scans a simpack directory for Qdyn6 `.inp` files, determines the run order, and extracts simulation parameters. Used internally for setting up simulations.

```APIDOC
## `scan.Scan` — Q6 Input File Scanner

Scans a simpack directory for Qdyn6 `.inp` files, resolves the run order, and returns the topology, FEP file, ordered list of input files, total steps, and total simulated time (in femtoseconds). Used internally by `ensemble.Worker` to set up each simulation.

### Usage:
```python
from cadee.dyn.scan import Scan
import os

os.chdir('/path/to/simpack_dir')
s = Scan()                  # scans current directory
topology, fepfile, inputfiles, total_steps, total_fs = s.scan()

print('Topology:', topology)          # e.g. 'mutant.top'
print('FEP file:', fepfile)           # e.g. 'mutant.fep'
print('Input files:', inputfiles[:3]) # e.g. ['0001_min.inp','0002_eq.inp',...]
print('Steps:', total_steps)          # e.g. 5000000
print('Sim time (fs):', total_fs)     # e.g. 10000000.0  (10 ns)

# Scan a specific directory
s2 = Scan('/path/to/another_simpack')
result = s2.scan()
```
```

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

### Generate interactive HTML visualization with CADEE ana alanize

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Read the `cadee.db` file and generate an interactive Plotly box-plot visualization of dG‡ and dG⁰ using `cadee ana alanize`. The output is saved as `index.html`.

```bash
cadee ana alanize ./ala_scan/cadee.db
```

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

### Load Required Modules

Source: https://github.com/kamerlinlab/cadee/blob/master/doc/example_installation_hpc2n_abisko.md

Load the intel and mpi modules required for compilation and execution.

```bash
module add intel/2017b iimpi/2017b
```

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

### Submit Simulation Jobs

Source: https://github.com/kamerlinlab/cadee/blob/master/workflow.md

Submits simulation jobs using MPI. Adjust MPI_ENVIRONMENT and N to match your system's configuration.

```bash
MPI_ENVIRONMENT -n N cadee dyn /path/to/simpacks
```

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

### Prepare and Alanine Scan for Mutants

Source: https://github.com/kamerlinlab/cadee/blob/master/workflow.md

Generates an alanine scan for a specified number of mutants, creating subfolders with topology and FEP files for each mutant.

```bash
cadee prep wt.pdb wt.fep qprep6.inp ./libraries --alascan --nummuts 16
```

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

### Generate Complex Mutation Inputs with SCWRL4

Source: https://github.com/kamerlinlab/cadee/blob/master/INSTALL.md

Demonstrates powerful options for generating mutation input files using SCWRL4, including saturation, specific amino acid sets, and combinations of mutations across multiple residues.

```bash
--libmut 137:SATURATE (20AA)
--libmut 137:POLAR (9AA)
--libmut 137:NEGATIVE (2AA)
--libmut 137:UNCHARGED (4AA)
--libmut 137:SHRINK (variable)
--libmut 137:'CGP' (3AA)
--libmut 137:'DEKCPG' (6AA)
-OR-
--libmut 137:'DEKCPG' 138:'DEKCPG' (6AAx6AA=36AA)
--libmut 137:'DEKCPG' 138:'DEKCPG' 139:SATURATE (6AAx6AAx20=720AA)
```

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

### Analyze Simulation Results

Source: https://github.com/kamerlinlab/cadee/blob/master/workflow.md

Provides help information for analyzing simulation results stored in cadee.db. Output can be generated in CSV or HTML format.

```bash
cadee ana --help
```

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

### Generate Alanine Scan Input Files

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Identifies mutatable residues within a specified radius, generates modified PDB files with alanine substitutions, and prepares simulation input files using Qprep6. Useful for scanning protein active sites.

```python
from cadee.prep.alascan import main, get_number_mutatable

# Count how many residues can be mutated with a 15 Å radius
n = get_number_mutatable('wt.pdb', 'wt.fep', 'qprep6.qpinp', mutate_radius=15.0)
print('Mutable residues:', n)  # e.g. 23

# Generate all alanine-scan simpacks into ./ala_scan/
main(
    wtpdb='wt.pdb',
    wtfep='wt.fep',
    qprep5inp='qprep6.qpinp',
    outputfolder='./ala_scan',
    mutate_radius=15.0
)
# Creates ./ala_scan/LEU45ALA/, ./ala_scan/ARG137ALA/, ... each with:
#   raw_mutant.pdb, mutant.top, mutant.fep, qprep6.qpinp
```

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

### Export Simulation Data to CSV

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Exports activation barriers or reaction free energies from cadee.db to a semicolon-delimited CSV file. Supports command-line and programmatic usage.

```bash
# Export activation barriers
cadee ana csv cadee.db dGstar.csv
# Output: dGstar.csv
# mutant;replik;wt;ARG15ALA;LYS22ALA;...
# 1100_eq;0;12.3;14.1;11.8;...

# Export reaction free energies (exothermicity)
cadee ana csv_exo cadee.db ddG.csv
```

```python
from cadee.ana.export_to_csv import main
main(['prog', 'cadee.db', 'out.csv'])            # exports barr_forw
main(['prog', 'cadee.db', 'out_exo.csv'], 'exo') # exports exo
```

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

### Generate Alanine Scan Inputs

Source: https://github.com/kamerlinlab/cadee/blob/master/INSTALL.md

Creates input files for an alanine scan of up to 16 mutants. This generates topology and FEP files in subfolders within 'ala_scan'.

```bash
./cadee.py wt.pdb wt.fep qprep5.inp ./libraries --alascan --nummuts 16
```

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

### Adjust Local Directory for Job Execution

Source: https://github.com/kamerlinlab/cadee/blob/master/doc/example_installation_hpc2n_abisko.md

Relocate the ~/.local directory to persistent storage (pfs) and create a symbolic link to ensure accessibility when running jobs.

```bash
cd ~
mv ~/.local ~/pfs/.local
ln -s  ~/pfs/.local .local
```

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

### config.SatLibs.get_lib — Amino Acid Library Lookup

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Maps named amino-acid group strings to a list of 1-letter amino-acid codes. Supports pre-defined groups and custom libraries. Raises an exception for invalid input.

```APIDOC
## `config.SatLibs.get_lib` — Amino Acid Library Lookup

Maps named amino-acid group strings (or custom single-letter codes) to a list of 1-letter amino-acid codes used as mutation targets.

### Usage:
```python
from cadee.prep.config import SatLibs

# Pre-defined groups
print(SatLibs.get_lib('SATURATE'))    # all 20 standard AA
print(SatLibs.get_lib('NEGATIVE'))    # ['D', 'E']
print(SatLibs.get_lib('POSITIVE'))    # ['R', 'H', 'K']
print(SatLibs.get_lib('UNCHARGED'))   # ['S', 'T', 'N', 'Q']
print(SatLibs.get_lib('APOLAR'))      # ['A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W']
print(SatLibs.get_lib('NDT'))         # 12-member NDT codon library

# Custom library (any subset of 1-letter codes, each used at most once)
print(SatLibs.get_lib('CGP'))         # ['C', 'G', 'P']
print(SatLibs.get_lib('DEKCPG'))      # ['D', 'E', 'K', 'C', 'P', 'G']

# Invalid input raises Exception
try:
    SatLibs.get_lib('XZB')
except Exception as e:
    print(e)  # Invalid 1-Letter Code: X
```
```

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

### Force re-mapping during ensemble MD simulation

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Use the `--force_map` flag with `cadee dyn` to force re-mapping even if `cadee.db` already exists. This ensures that mapping is recalculated.

```bash
mpirun -n 8 cadee dyn ./ala_scan --alpha 0.5 --hij 10.0 --force_map
```

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

### Generate Combinatorial Sequence Libraries

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Creates a combinatorial library of protein sequences by substituting specified positions with amino acids from predefined or custom libraries. The wild-type sequence is always included.

```python
from cadee.prep.genseqs import genseq2

wt_fasta = 'mklvingtrwca'   # lowercase 1-letter FASTA
# Mutate position 5 (1-based) to E or K, AND position 9 to R or H
mutations = [
    (5, ['E', 'K']),
    (9, ['R', 'H']),
]
sequences = genseq2(wt_fasta, mutations)
# Returns list of sequences (as lists of chars), including wild-type:
# ['m','k','l','v','i','n','g','t','r','w','c','a']  <- wt
# ['m','k','l','v','E','n','g','t','r','w','c','a']  <- pos5=E
# ['m','k','l','v','K','n','g','t','r','w','c','a']  <- pos5=K
# ... (2+1) * (2+1) = 9 sequences total including wt
print(len(sequences))  # 9
```

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

### alascan.main — Alanine Scan Input Generator

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Generates alanine scan input files by identifying mutatable residues, creating modified PDBs, and calling Qprep6. Supports programmatic usage for generating simulation packs.

```APIDOC
## `alascan.main` — Alanine Scan Input Generator

Identifies mutatable residues within a sphere around the active site (non-ALA, non-GLY, not in the FEP region), writes a modified PDB with the target residue replaced by ALA, and calls Qprep6 to generate the topology/FEP pair.

### Programmatic Usage:
```python
from cadee.prep.alascan import main, get_number_mutatable

# Count how many residues can be mutated with a 15 Å radius
n = get_number_mutatable('wt.pdb', 'wt.fep', 'qprep6.qpinp', mutate_radius=15.0)
print('Mutable residues:', n)  # e.g. 23

# Generate all alanine-scan simpacks into ./ala_scan/
main(
    wtpdb='wt.pdb',
    wtfep='wt.fep',
    qprep5inp='qprep6.qpinp',
    outputfolder='./ala_scan',
    mutate_radius=15.0
)
# Creates ./ala_scan/LEU45ALA/, ./ala_scan/ARG137ALA/, ... each with:
#   raw_mutant.pdb, mutant.top, mutant.fep, qprep6.qpinp
```
```

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

### Override temporary directory for ensemble MD simulation

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Set the `CADEE_TMP` environment variable to override the default temporary directory used by `cadee dyn` for simulations. This is useful for managing disk space or performance.

```bash
CADEE_TMP=/fast_scratch mpirun -n 16 cadee dyn ./libmut
```

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

### cadee ana csv / cadee ana csv_exo — CSV Export

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Exports activation barriers or reaction free energies from cadee.db into a semicolon-delimited CSV file. Supports both command-line and programmatic usage.

```APIDOC
## `cadee ana csv` / `cadee ana csv_exo` — CSV Export

Exports activation barriers (dG‡, `barr_forw`) or reaction free energies (dG⁰, `exo`) from `cadee.db` into a semicolon-delimited CSV file, with mutants as columns and replicate/simulation-step rows.

### Command-line Usage:
```bash
# Export activation barriers
cadee ana csv cadee.db dGstar.csv
# Output: dGstar.csv
# mutant;replik;wt;ARG15ALA;LYS22ALA;...
# 1100_eq;0;12.3;14.1;11.8;...

# Export reaction free energies (exothermicity)
cadee ana csv_exo cadee.db ddG.csv
```

### Programmatic Usage:
```python
from cadee.ana.export_to_csv import main

# exports barr_forw
main(['prog', 'cadee.db', 'out.csv'])

# exports exo
main(['prog', 'cadee.db', 'out_exo.csv'], 'exo')
```
```

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

### Concatenate Cadee Databases

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Merges multiple cadee.db SQLite databases into a single file, normalizing mutant names by stripping replicate suffixes. Useful for pooling results from separate runs.

```bash
cadee ana cat run1/cadee.db run2/cadee.db run3/cadee.db
# Output: ./concat_cadee.db  (fails if file already exists)
```

```python
from cadee.ana.cat_cadee_dbs import main
main(['run1/cadee.db', 'run2/cadee.db'])
# Each row's mutant field is normalized: "ARG15ALA_1" → "ARG15ALA"
```

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

### cadee ana cat — Concatenate Databases

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Merges two or more `cadee.db` SQLite databases into a single `concat_cadee.db`, normalizing mutant names to pool results from separate cluster runs. Supports command-line and programmatic usage.

```APIDOC
## `cadee ana cat` — Concatenate Databases

Merges two or more `cadee.db` SQLite databases into a single `concat_cadee.db`, stripping replicate suffixes from mutant names so that results from separate cluster runs can be pooled.

### Command-line Usage:
```bash
cadee ana cat run1/cadee.db run2/cadee.db run3/cadee.db
# Output: ./concat_cadee.db  (fails if file already exists)
```

### Programmatic Usage:
```python
from cadee.ana.cat_cadee_dbs import main

main(['run1/cadee.db', 'run2/cadee.db'])
# Each row's mutant field is normalized: "ARG15ALA_1" → "ARG15ALA"
```
```

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

### Amino Acid Library Lookup

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Maps named amino-acid group strings (e.g., 'SATURATE', 'NEGATIVE') or custom codes to lists of 1-letter amino-acid codes. Used for defining mutation targets in sequence generation.

```python
from cadee.prep.config import SatLibs

# Pre-defined groups
print(SatLibs.get_lib('SATURATE'))    # all 20 standard AA
print(SatLibs.get_lib('NEGATIVE'))    # ['D', 'E']
print(SatLibs.get_lib('POSITIVE'))    # ['R', 'H', 'K']
print(SatLibs.get_lib('UNCHARGED'))   # ['S', 'T', 'N', 'Q']
print(SatLibs.get_lib('APOLAR'))      # ['A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W']
print(SatLibs.get_lib('NDT'))         # 12-member NDT codon library

# Custom library (any subset of 1-letter codes, each used at most once)
print(SatLibs.get_lib('CGP'))         # ['C', 'G', 'P']
print(SatLibs.get_lib('DEKCPG'))      # ['D', 'E', 'K', 'C', 'P', 'G']

# Invalid input raises Exception
try:
    SatLibs.get_lib('XZB')
except Exception as e:
    print(e)  # Invalid 1-Letter Code: X
```

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

### genseqs.genseq2 — Sequence Library Generator

Source: https://context7.com/kamerlinlab/cadee/llms.txt

Generates a combinatorial sequence library by substituting specified residue positions with amino acids from predefined or custom libraries. The wild-type sequence is always included.

```APIDOC
## `genseqs.genseq2` — Sequence Library Generator

Generates a combinatorial sequence library by substituting specified residue positions with amino acids from predefined or custom libraries. The wild-type sequence is always included.

### Usage:
```python
from cadee.prep.genseqs import genseq2

wt_fasta = 'mklvingtrwca'   # lowercase 1-letter FASTA
# Mutate position 5 (1-based) to E or K, AND position 9 to R or H
mutations = [
    (5, ['E', 'K']),
    (9, ['R', 'H']),
]
sequences = genseq2(wt_fasta, mutations)
# Returns list of sequences (as lists of chars), including wild-type:
# ['m','k','l','v','i','n','g','t','r','w','c','a']  <- wt
# ['m','k','l','v','E','n','g','t','r','w','c','a']  <- pos5=E
# ['m','k','l','v','K','n','g','t','r','w','c','a']  <- pos5=K
# ... (2+1) * (2+1) = 9 sequences total including wt
print(len(sequences))  # 9
```
```

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