Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,47 @@
 *.7z filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
+*.bin.* filter=lfs diff=lfs merge=lfs -text
 *.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
 *.ftz filter=lfs diff=lfs merge=lfs -text
 *.gz filter=lfs diff=lfs merge=lfs -text
 *.h5 filter=lfs diff=lfs merge=lfs -text
 *.joblib filter=lfs diff=lfs merge=lfs -text
 *.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
 *.model filter=lfs diff=lfs merge=lfs -text
 *.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
 *.onnx filter=lfs diff=lfs merge=lfs -text
 *.ot filter=lfs diff=lfs merge=lfs -text
 *.parquet filter=lfs diff=lfs merge=lfs -text
 *.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
 *.pth filter=lfs diff=lfs merge=lfs -text
 *.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
 saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
 *.tflite filter=lfs diff=lfs merge=lfs -text
 *.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
 *.xz filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
+*.zstandard filter=lfs diff=lfs merge=lfs -text
+*.tfevents* filter=lfs diff=lfs merge=lfs -text
+*.db* filter=lfs diff=lfs merge=lfs -text
+*.ark* filter=lfs diff=lfs merge=lfs -text
+**/*ckpt*data* filter=lfs diff=lfs merge=lfs -text
+**/*ckpt*.meta filter=lfs diff=lfs merge=lfs -text
+**/*ckpt*.index filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.gguf* filter=lfs diff=lfs merge=lfs -text
+*.ggml filter=lfs diff=lfs merge=lfs -text
+*.llamafile* filter=lfs diff=lfs merge=lfs -text
+*.pt2 filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -textconf/fig-overview.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+output
+output_saturation
+analysis_output
+questions
+ddG-backrub-per_chain.xml

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Kyle Barlow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,325 @@
+---
+license: mit
+language:
+- en
+- zh
+tags:
+- OneScience
+- life-science
+- protein
+- binding-affinity
+- mutation
+- Rosetta
+frameworks: Other
+---
+
+<p align="center">
+  <strong>
+    <span style="font-size: 30px;">Flex ddG</span>
+  </strong>
+</p>
+
+# Model Introduction
+
+Flex ddG is a Rosetta-based workflow for predicting the effects of mutations at protein-protein interfaces and estimating changes in binding free energy before and after mutation (interface ΔΔG). It uses the Rosetta Backrub protocol to sample local backbone conformations, then performs side-chain repacking, structural minimization, and interface energy calculations for the wild type and mutant to assess how mutations affect protein binding affinity.
+
+Paper:
+
+> **Flex ddG: Rosetta Ensemble-Based Estimation of Changes in Protein–Protein Binding Affinity upon Mutation**  
+> https://doi.org/10.1021/acs.jpcb.7b11367
+
+# Model Description
+
+Flex ddG is not a model that relies on neural network weights; it is a computational workflow based on the Rosetta energy function and conformational sampling. Inputs typically include a protein complex PDB file, interface chain information, and a Rosetta resfile describing the mutations. The workflow uses Backrub sampling to generate an ensemble of conformations, optimizes and calculates interface energies for the wild type and mutant separately, and ultimately produces ΔΔG.
+
+# Use Cases
+
+| Use case | Description |
+| --- | --- |
+| Protein-protein interface mutation effect prediction | Predict changes in binding free energy ΔΔG caused by mutations |
+| Interface hotspot residue analysis | Evaluate the effects of mutations at specific sites on binding stability |
+| Single-site saturation mutagenesis scan | Generate all 20 standard amino acid substitutions at a target site and calculate ΔΔG for each |
+| Protein engineering and interface optimization | Help screen for mutations that may enhance or weaken protein interactions |
+
+# Usage
+
+## 1. Using OneCode
+
+Experience intelligent one-click AI4S programming in the OneCode online environment:
+
+[Try intelligent one-click AI4S programming](https://web-2069360198568017922-iaaj.ksai.scnet.cn:58043/home)
+
+## 2. Manual Installation and Usage
+
+**Hardware Requirements**
+
+- The core computations in Flex ddG are performed by Rosetta CPU programs; the standard workflow does not require a GPU/DCU.
+- The official Python scripts use `multiprocessing` to launch multiple Rosetta instances concurrently. Each Rosetta instance requires approximately 2 GB of memory, so set the concurrency level according to the number of CPU cores and the node's available memory.
+
+### Set Up the Runtime Environment
+
+#### DCU Environment
+
+```bash
+# Activate DTK and CONDA first
+conda create -n onescience311 python=3.11 -y
+conda activate onescience311
+
+# Install with uv support
+pip install onescience[bio] \
+  -i http://mirrors.onescience.ai:3141/pypi/simple/ \
+  --trusted-host mirrors.onescience.ai
+```
+
+#### Environment Notes
+
+- The core dependency of Flex ddG is **Rosetta**. The main workflow requires the `rosetta_scripts` executable built by Rosetta.
+
+
+### Install Rosetta
+
+Flex ddG does not require neural network model weights or additional large datasets, but Rosetta must be installed separately.
+
+#### 1) Install Rosetta
+
+Rosetta must be licensed, downloaded, and installed separately according to the official RosettaCommons instructions:
+
+```text
+https://www.rosettacommons.org/software
+```
+
+The Rosetta license is independent of the MIT License for the Flex ddG tutorial repository. Academic and non-commercial users can apply for a non-commercial license; commercial use requires a separate license.
+
+After installation, make sure that at least the following files exist:
+
+```text
+/path/to/rosetta/source/bin/rosetta_scripts
+/path/to/rosetta/source/bin/score_jd2
+```
+
+#### 2) Configure the Rosetta Paths
+
+Before running the workflow, update the following line in `scripts/run_example_1.py` and `scripts/run_example_2_saturation.py`:
+
+```python
+rosetta_scripts_path = os.path.expanduser("~/rosetta/source/bin/rosetta_scripts")
+```
+
+To run `scripts/extract_structures.py`, also update `score_jd2_path` in the script to the actual path of the Rosetta `score_jd2` executable.
+
+## 3. Quick Start
+
+### Download the Model Package
+
+```bash
+hf download OneScience-Group/flex_ddG --local-dir ./flex_ddG
+cd flex_ddG
+```
+
+- Flex ddG **additionally depends on Rosetta**. Rosetta is not included in this model repository; first apply for a license and install Rosetta as described in "Install Rosetta", then configure `rosetta_scripts_path`.
+- To extract PDB structures from `struct.db3`, you also need to configure the path to Rosetta's `score_jd2` executable.
+- The default parameters in this document are intended only for quick functional verification and do not represent parameters for production scientific calculations.
+
+### Quick Verification
+
+First, verify that the Rosetta executable is available:
+
+```bash
+/path/to/rosetta/source/bin/rosetta_scripts -help
+```
+
+Run the official example:
+
+```bash
+python scripts/run_example_1.py
+```
+
+On success, the following directory will be generated:
+
+```text
+output/
+```
+
+# Example Data
+
+The official example directory is:
+
+```text
+scripts/inputs/
+└── 1JTG/
+    ├── 1JTG_AB.pdb
+    ├── chains_to_move.txt
+    ├── nataa_mutations.resfile
+    ├── mutations.resfile
+    ├── mutations.mutfile
+    ├── pdb2rosetta.resmap.json
+    └── rosetta2pdb.resmap.json
+```
+
+The files are:
+
+| File | Description |
+| --- | --- |
+| `1JTG_AB.pdb` | Protein complex structure |
+| `chains_to_move.txt` | Defines the chain that moves as one side of the interface during calculations |
+| `nataa_mutations.resfile` | The mutation resfile used by Flex ddG |
+| `mutations.resfile` | Example mutation configuration |
+| `mutations.mutfile` | Example mutation information |
+
+The resfile used by Flex ddG must begin with `NATAA`. The official scripts explicitly state that it should not be replaced with `NATRO`, as this changes the repacking behavior of residues near the mutant and introduces bias into ΔΔG.
+
+For your own tasks, you typically need at least:
+
+```text
+Complex PDB
++ Interface chain information
++ A resfile describing the mutations
+```
+# Inference Examples
+## Flex ddG Calculation for Specified Mutations
+Make sure that the Rosetta path in `scripts/run_example_1.py` is configured correctly:
+
+```python
+rosetta_scripts_path = "/path/to/rosetta/source/bin/rosetta_scripts"
+```
+
+Run:
+
+```bash
+python scripts/run_example_1.py
+```
+
+The script reads the complex structure, `chains_to_move.txt`, and `nataa_mutations.resfile` from `scripts/inputs/`, then calls `conf/ddG-backrub.xml` to run Flex ddG.
+
+Key parameters:
+
+| Parameter | Default | Common production setting/meaning |
+| --- | ---: | --- |
+| `nstruct` | 3 | Typically about 35 or more independent replicates in production |
+| `number_backrub_trials` | 10 | 35000 is commonly used in the official benchmark |
+| `max_minimization_iter` | 5 | Standard value: 5000 |
+| `abs_score_convergence_thresh` | 200.0 | Standard value: 1.0 |
+| `backrub_trajectory_stride` | 5 | Controls the interval between Backrub trajectory checkpoints |
+
+The small parameter values in this document are intended to shorten runtime and should not be used directly for production ΔΔG calculations.
+
+## Single-Site Saturation Mutagenesis
+
+Run:
+
+```bash
+python scripts/run_example_2_saturation.py
+```
+
+The script sequentially generates a resfile for each of the 20 standard amino acid substitutions at the specified residue and runs Flex ddG.
+
+Configure the target site in the script:
+
+```python
+residue_to_mutate = ('B', 49, '')
+```
+
+The format is:
+
+```text
+(chain ID, PDB residue number, insertion code)
+```
+
+Results are saved in:
+
+```text
+output_saturation/
+```
+
+## Parallel Execution Recommendations
+
+The official scripts use the following defaults:
+
+```python
+use_multiprocessing = True
+max_cpus = 2
+```
+
+During actual execution, adjust `max_cpus` according to the allocated number of CPU cores and the node's available memory. Each Rosetta instance uses CPU and memory independently, so setting it to all available cores unconditionally is not recommended.
+
+# Result Analysis
+
+After Example 1 is complete:
+
+```bash
+python scripts/analyze_flex_ddG.py output
+```
+
+For saturation mutagenesis results:
+
+```bash
+python scripts/analyze_flex_ddG.py output_saturation
+```
+
+The analysis script outputs:
+
+```text
+wt_dG
+mut_dG
+ΔΔG
+```
+
+The results are written to:
+
+```text
+analysis_output/
+```
+
+the CSV files in this directory. It also provides reweighted mutant ΔΔG values using the GAM model fitted in the original Flex ddG paper.
+
+To extract structures after Backrub, wild-type minimization, or mutant minimization:
+
+```bash
+python scripts/extract_structures.py output
+```
+
+The script looks for `struct.db3` and calls Rosetta `score_jd2` to export PDB files.
+
+# Output Description
+
+After running `scripts/run_example_1.py`, the main results are located at:
+
+```text
+output/
+└── <case>/
+    └── <replicate>/
+        ├── rosetta.out
+        ├── ddG.db3
+        └── struct.db3
+```
+
+The files are:
+
+| File | Description |
+| --- | --- |
+| `rosetta.out` | Rosetta run log |
+| `ddG.db3` | Database of Flex ddG energy and trajectory results |
+| `struct.db3` | Database of structures generated by Rosetta |
+| `analysis_output/*.csv` | Summary of ΔΔG results generated by `scripts/analyze_flex_ddG.py` |
+
+The analysis script reads the Backrub trajectory stride from the `ddG.db3` generated by each run, so you usually do not need to modify the analysis script manually. If the database does not contain a stride, use:
+
+```bash
+python scripts/analyze_flex_ddG.py output --stride N
+```
+to override it.
+
+# Official OneScience Information
+
+| Platform | Main OneScience repository | Skills repository |
+| --- | --- | --- |
+| Gitee | https://gitee.com/onescience-ai/onescience | https://gitee.com/onescience-ai/oneskills |
+| GitHub | https://github.com/onescience-ai/OneScience | https://github.com/onescience-ai/oneskills |
+
+# Citation and License
+
+- Original Flex ddG paper: [Flex ddG: Rosetta Ensemble-Based Estimation of Changes in Protein–Protein Binding Affinity upon Mutation](https://doi.org/10.1021/acs.jpcb.7b11367).
+- Flex ddG uses the Rosetta Backrub conformational sampling method. Related paper: [Backrub-Like Backbone Simulation Recapitulates Natural Protein Conformational Variability and Improves Mutant Side-Chain Prediction](https://doi.org/10.1016/j.jmb.2008.05.023).
+- The official flex_ddG_tutorial source code is released under the MIT License; see `LICENSE` in the repository root.
+- **Rosetta is not covered by the MIT License of the Flex ddG tutorial repository.** Rosetta is distributed under a separate software license; academic and non-commercial users can apply for a non-commercial license, while commercial use requires a separate commercial license.
+- For research use, we recommend citing the relevant Flex ddG, Backrub, and Rosetta publications, and adding citations as required by the relevant OneScience project.

conf/ddG-backrub.xml

@@ -0,0 +1,114 @@
+<ROSETTASCRIPTS>
+  <SCOREFXNS>
+    <ScoreFunction name="fa_talaris2014" weights="talaris2014"/>
+    <ScoreFunction name="fa_talaris2014_cst" weights="talaris2014">
+      <Reweight scoretype="atom_pair_constraint" weight="1.0"/>
+      <Set fa_max_dis="9.0"/>
+    </ScoreFunction>
+  </SCOREFXNS>
+
+  <!-- ### Only required input file (other than PDB) - mutation resfile ### -->
+  <!-- #### All residues must be set to be NATAA packable at top of resfile ### -->
+  <TASKOPERATIONS>
+    <ReadResfile name="res_mutate" filename="%%mutate_resfile_relpath%%"/>
+  </TASKOPERATIONS>
+
+  <RESIDUE_SELECTORS>
+    <Task name="resselector" fixed="0" packable="0" designable="1" task_operations="res_mutate"/>
+    <Neighborhood name="bubble" selector="resselector" distance="8.0"/>
+    <PrimarySequenceNeighborhood name="bubble_adjacent" selector="bubble" lower="1" upper="1"/>
+    <StoredResidueSubset name="restore_neighbor_shell" subset_name="neighbor_shell"/>
+    <Not name="everythingelse" selector="restore_neighbor_shell"/>
+  </RESIDUE_SELECTORS>
+  <TASKOPERATIONS>
+    <OperateOnResidueSubset name="repackonly" selector="restore_neighbor_shell">
+      <RestrictToRepackingRLT/>
+    </OperateOnResidueSubset>
+    <OperateOnResidueSubset name="norepack" selector="everythingelse">
+      <PreventRepackingRLT/>
+    </OperateOnResidueSubset>
+    <UseMultiCoolAnnealer name="multicool" states="6"/>
+    <ExtraChiCutoff name="extrachizero" extrachi_cutoff="0"/>
+    <InitializeFromCommandline name="commandline_init"/>
+    <RestrictToRepacking name="restrict_to_repacking"/>
+  </TASKOPERATIONS>
+
+  <FILTERS>
+  </FILTERS>
+
+  <MOVERS>
+    <StoreResidueSubset name="neighbor_shell_storer" subset_name="neighbor_shell" residue_selector="bubble_adjacent" />
+
+    <AddConstraintsToCurrentConformationMover name="addcst" use_distance_cst="1" coord_dev="0.5" min_seq_sep="0" max_distance="9" CA_only="1" bound_width="0.0" cst_weight="0.0"/>
+    <ClearConstraintsMover name="clearcst"/>
+    <MinMover name="minimize" scorefxn="fa_talaris2014_cst" chi="1" bb="1" type="lbfgs_armijo_nonmonotone" tolerance="0.000001" max_iter="%%max_minimization_iter%%" abs_score_convergence_threshold="%%abs_score_convergence_thresh%%"/>
+
+    <PackRotamersMover name="repack" scorefxn="fa_talaris2014" task_operations="commandline_init,repackonly,norepack,multicool"/>
+    <PackRotamersMover name="mutate" scorefxn="fa_talaris2014" task_operations="commandline_init,res_mutate,norepack,multicool"/>
+
+    <ReportToDB name="dbreport" batch_description="interface_ddG" database_name="ddG.db3">
+      <ScoreTypeFeatures/>
+      <ScoreFunctionFeatures scorefxn="fa_talaris2014"/>
+      <StructureScoresFeatures scorefxn="fa_talaris2014"/>
+    </ReportToDB>
+
+    <ReportToDB name="structreport" batch_description="interface_ddG_struct" database_name="struct.db3">
+      <PoseConformationFeatures/>
+      <PdbDataFeatures/>
+      <JobDataFeatures/>
+      <ResidueFeatures/>
+      <PoseCommentsFeatures/>
+      <ProteinResidueConformationFeatures/>
+      <ResidueConformationFeatures/>
+    </ReportToDB>
+
+    <SavePoseMover name="save_wt_bound_pose" restore_pose="0" reference_name="wt_bound_pose"/>
+    <SavePoseMover name="save_backrub_pose" restore_pose="0" reference_name="backrubpdb"/>
+    <SavePoseMover name="restore_backrub_pose" restore_pose="1" reference_name="backrubpdb"/>
+
+    <InterfaceDdGMover name="int_ddG_mover" wt_ref_savepose_mover="save_wt_bound_pose" chain_name="%%chainstomove%%" db_reporter="dbreport" scorefxn="fa_talaris2014"/>
+
+    <ScoreMover name="apply_score" scorefxn="fa_talaris2014_cst" verbose="0"/>
+
+    <!-- This ParsedProtocol allows the ddG calculation to take place multiple times along the backrub trajectory, if desired -->
+    <ParsedProtocol name="finish_ddg_post_backrub">
+      <Add mover_name="save_backrub_pose"/>
+      <Add mover_name="structreport"/>
+
+      <Add mover_name="repack"/>
+
+      <Add mover_name="addcst"/>
+      <Add mover_name="minimize"/>
+      <Add mover_name="clearcst"/>
+
+      <Add mover_name="save_wt_bound_pose"/>
+      <Add mover_name="structreport"/>
+      <Add mover_name="restore_backrub_pose"/>
+
+      <Add mover_name="mutate"/>
+
+      <Add mover_name="addcst"/>
+      <Add mover_name="minimize"/>
+      <Add mover_name="clearcst"/>
+      <Add mover_name="structreport"/>
+
+      <Add mover_name="int_ddG_mover"/>
+    </ParsedProtocol>
+
+    <BackrubProtocol name="backrub" mc_kt="1.2" ntrials="%%number_backrub_trials%%" pivot_residue_selector="restore_neighbor_shell" task_operations="restrict_to_repacking,commandline_init,extrachizero" recover_low="0" trajectory_stride="%%backrub_trajectory_stride%%" trajectory_apply_mover="finish_ddg_post_backrub"/>
+
+  </MOVERS>
+  <APPLY_TO_POSE>
+  </APPLY_TO_POSE>
+  <PROTOCOLS>
+    <Add mover_name="addcst"/>
+    <Add mover_name="apply_score"/> <!-- Necessary to initialize neighbor graph -->
+    <Add mover_name="neighbor_shell_storer"/>
+
+    <Add mover_name="minimize"/>
+    <Add mover_name="clearcst"/>
+
+    <Add mover_name="backrub"/>
+  </PROTOCOLS>
+  <OUTPUT />
+</ROSETTASCRIPTS>

conf/ddG-no_backrub_control.xml

@@ -0,0 +1,108 @@
+<ROSETTASCRIPTS>
+  <SCOREFXNS>
+    <ScoreFunction name="fa_talaris2014" weights="talaris2014"/>
+    <ScoreFunction name="fa_talaris2014_cst" weights="talaris2014">
+      <Reweight scoretype="atom_pair_constraint" weight="1.0"/>
+      <Set fa_max_dis="9.0"/>
+    </ScoreFunction>
+  </SCOREFXNS>
+
+  <!-- ### Only required input file (other than PDB) - mutation resfile ### -->
+  <!-- #### All residues must be set to be NATAA packable at top of resfile ### -->
+  <TASKOPERATIONS>
+    <ReadResfile name="res_mutate" filename="%%mutate_resfile_relpath%%"/>
+  </TASKOPERATIONS>
+
+  <RESIDUE_SELECTORS>
+    <Task name="resselector" fixed="0" packable="0" designable="1" task_operations="res_mutate"/>
+    <Neighborhood name="bubble" selector="resselector" distance="8.0"/>
+    <PrimarySequenceNeighborhood name="bubble_adjacent" selector="bubble" lower="1" upper="1"/>
+    <StoredResidueSubset name="restore_neighbor_shell" subset_name="neighbor_shell"/>
+    <Not name="everythingelse" selector="restore_neighbor_shell"/>
+  </RESIDUE_SELECTORS>
+  <TASKOPERATIONS>
+    <OperateOnResidueSubset name="repackonly" selector="restore_neighbor_shell">
+      <RestrictToRepackingRLT/>
+    </OperateOnResidueSubset>
+    <OperateOnResidueSubset name="norepack" selector="everythingelse">
+      <PreventRepackingRLT/>
+    </OperateOnResidueSubset>
+    <UseMultiCoolAnnealer name="multicool" states="6"/>
+    <ExtraChiCutoff name="extrachizero" extrachi_cutoff="0"/>
+    <InitializeFromCommandline name="commandline_init"/>
+    <RestrictToRepacking name="restrict_to_repacking"/>
+  </TASKOPERATIONS>
+
+  <FILTERS>
+  </FILTERS>
+
+  <MOVERS>
+    <StoreResidueSubset name="neighbor_shell_storer" subset_name="neighbor_shell" residue_selector="bubble_adjacent" />
+
+    <AddConstraintsToCurrentConformationMover name="addcst" use_distance_cst="1" coord_dev="0.5" min_seq_sep="0" max_distance="9" CA_only="1" bound_width="0.0" cst_weight="0.0"/>
+    <ClearConstraintsMover name="clearcst"/>
+    <MinMover name="minimize" scorefxn="fa_talaris2014_cst" chi="1" bb="1" type="lbfgs_armijo_nonmonotone" tolerance="0.000001" max_iter="%%max_minimization_iter%%" abs_score_convergence_threshold="%%abs_score_convergence_thresh%%"/>
+
+    <PackRotamersMover name="repack" scorefxn="fa_talaris2014" task_operations="commandline_init,repackonly,norepack,multicool"/>
+    <PackRotamersMover name="mutate" scorefxn="fa_talaris2014" task_operations="commandline_init,res_mutate,norepack,multicool"/>
+
+    <ReportToDB name="dbreport" batch_description="interface_ddG" database_name="ddG.db3">
+      <ScoreTypeFeatures/>
+      <ScoreFunctionFeatures scorefxn="fa_talaris2014"/>
+      <StructureScoresFeatures scorefxn="fa_talaris2014"/>
+    </ReportToDB>
+
+    <ReportToDB name="structreport" batch_description="interface_ddG_struct" database_name="struct.db3">
+      <PoseConformationFeatures/>
+      <PdbDataFeatures/>
+      <JobDataFeatures/>
+      <ResidueFeatures/>
+      <PoseCommentsFeatures/>
+      <ProteinResidueConformationFeatures/>
+      <ResidueConformationFeatures/>
+    </ReportToDB>
+
+    <SavePoseMover name="save_wt_bound_pose" restore_pose="0" reference_name="wt_bound_pose"/>
+    <SavePoseMover name="save_backrub_pose" restore_pose="0" reference_name="backrubpdb"/>
+    <SavePoseMover name="restore_backrub_pose" restore_pose="1" reference_name="backrubpdb"/>
+
+    <InterfaceDdGMover name="int_ddG_mover" wt_ref_savepose_mover="save_wt_bound_pose" chain_name="%%chainstomove%%" db_reporter="dbreport" scorefxn="fa_talaris2014"/>
+
+    <ScoreMover name="apply_score" scorefxn="fa_talaris2014_cst" verbose="0"/>
+
+  </MOVERS>
+  <APPLY_TO_POSE>
+  </APPLY_TO_POSE>
+  <PROTOCOLS>
+    <Add mover_name="addcst"/>
+    <Add mover_name="apply_score"/> <!-- Necessary to initialize neighbor graph -->
+    <Add mover_name="neighbor_shell_storer"/>
+
+    <Add mover_name="minimize"/>
+    <Add mover_name="clearcst"/>
+
+    <Add mover_name="save_backrub_pose"/>
+    <Add mover_name="structreport"/>
+
+    <Add mover_name="repack"/>
+
+    <Add mover_name="addcst"/>
+    <Add mover_name="minimize"/>
+    <Add mover_name="clearcst"/>
+
+    <Add mover_name="save_wt_bound_pose"/>
+    <Add mover_name="structreport"/>
+    <Add mover_name="restore_backrub_pose"/>
+
+    <Add mover_name="mutate"/>
+
+    <Add mover_name="addcst"/>
+    <Add mover_name="minimize"/>
+    <Add mover_name="clearcst"/>
+    <Add mover_name="structreport"/>
+
+    <Add mover_name="int_ddG_mover"/>
+
+  </PROTOCOLS>
+  <OUTPUT />
+</ROSETTASCRIPTS>

conf/per_chain_rescore.xml

@@ -0,0 +1,66 @@
+<ROSETTASCRIPTS>
+  <!--
+    Reprocess an EXISTING flex ddG run to recover per-chain intramolecular energies.
+
+    No re-sampling is needed: struct.db3 already holds the coordinates of every backrub,
+    wild type minimized, and mutant minimized pose. This protocol reads those poses back in,
+    isolates one chain at a time, and reports the isolated chain's total score.
+
+    Isolating the chain matters. A Chain residue selector alone is not enough, because
+    struct.db3 stores the *bound* poses, so a selector-scoped metric still picks up cross-chain
+    pair energies (roughly half the interface energy leaks into each chain). Deleting the other
+    chains reproduces the separated, unrelaxed unbound state exactly, because intra-chain
+    energy is invariant under the rigid-body translation InterfaceDdGMover uses to unbind.
+
+    Chain selectors below are for a two chain A/B complex. Add one Chain selector, one
+    DeleteRegionMover, one ReportToDB and one restore/delete/report triple per extra chain.
+
+    Usage (run once per struct.db3, from the directory containing it):
+
+      rosetta_scripts -inout:dbms:database_name struct.db3 -in:use_database \
+                      -parser:protocol per_chain_rescore.xml \
+                      -restore_talaris_behavior -in:file:fullatom -out:nooutput
+
+    Then read per_chain.db3 with reprocess_per_chain.py.
+  -->
+  <SCOREFXNS>
+    <ScoreFunction name="fa_talaris2014" weights="talaris2014"/>
+  </SCOREFXNS>
+
+  <RESIDUE_SELECTORS>
+    <Chain name="chain_A" chains="A"/>
+    <Chain name="chain_B" chains="B"/>
+    <Not name="not_chain_A" selector="chain_A"/>
+    <Not name="not_chain_B" selector="chain_B"/>
+  </RESIDUE_SELECTORS>
+
+  <MOVERS>
+    <SavePoseMover name="save_full" reference_name="full_pose" restore_pose="0"/>
+    <SavePoseMover name="restore_full" reference_name="full_pose" restore_pose="1"/>
+
+    <DeleteRegionMover name="isolate_chain_A" residue_selector="not_chain_A"/>
+    <DeleteRegionMover name="isolate_chain_B" residue_selector="not_chain_B"/>
+
+    <ReportToDB name="chain_A_report" batch_description="per_chain" database_name="per_chain.db3">
+      <ScoreTypeFeatures/>
+      <ScoreFunctionFeatures scorefxn="fa_talaris2014"/>
+      <StructureScoresFeatures scorefxn="fa_talaris2014"/>
+    </ReportToDB>
+    <ReportToDB name="chain_B_report" batch_description="per_chain" database_name="per_chain.db3">
+      <ScoreTypeFeatures/>
+      <ScoreFunctionFeatures scorefxn="fa_talaris2014"/>
+      <StructureScoresFeatures scorefxn="fa_talaris2014"/>
+    </ReportToDB>
+  </MOVERS>
+
+  <PROTOCOLS>
+    <Add mover_name="save_full"/>
+    <Add mover_name="isolate_chain_A"/>
+    <Add mover_name="chain_A_report"/>
+
+    <Add mover_name="restore_full"/>
+    <Add mover_name="isolate_chain_B"/>
+    <Add mover_name="chain_B_report"/>
+  </PROTOCOLS>
+  <OUTPUT />
+</ROSETTASCRIPTS>

conf/split_protocol/flex_ddG-backrub_step.xml

@@ -0,0 +1,108 @@
+<ROSETTASCRIPTS>
+  <SCOREFXNS>
+    <ScoreFunction name="fa_fxn" weights="talaris2014">
+    </ScoreFunction>
+    <ScoreFunction name="fa_fxn_cst" weights="talaris2014">
+      <Reweight scoretype="atom_pair_constraint" weight="1.0"/>
+      <Set fa_max_dis="9.0"/>
+    </ScoreFunction>
+  </SCOREFXNS>
+
+  <!-- ### Only required input - mutation resfile ### -->
+  <!-- #### All residues must be set to be NATAA packable at top of resfile ### -->
+  <TASKOPERATIONS>
+    <ReadResfile name="res_mutate" filename="%%mutate_resfile_relpath%%"/>
+  </TASKOPERATIONS>
+
+  <RESIDUE_SELECTORS>
+    <Task name="resselector" fixed="0" packable="0" designable="1" task_operations="res_mutate"/>
+    <Neighborhood name="bubble" selector="resselector" distance="%%neighbor_distance%%" include_focus_in_subset="true"/>
+    <PrimarySequenceNeighborhood name="bubble_adjacent" selector="bubble" lower="1" upper="1"/>
+    <StoredResidueSubset name="restore_neighbor_shell" subset_name="neighbor_shell"/>
+    <Not name="everythingelse" selector="restore_neighbor_shell"/>
+  </RESIDUE_SELECTORS>
+  <TASKOPERATIONS>
+    <OperateOnResidueSubset name="repackonly" selector="restore_neighbor_shell">
+      <RestrictToRepackingRLT/>
+    </OperateOnResidueSubset>
+    <OperateOnResidueSubset name="norepack" selector="everythingelse">
+      <PreventRepackingRLT/>
+    </OperateOnResidueSubset>
+    <UseMultiCoolAnnealer name="multicool" states="6"/>
+    <ExtraChiCutoff name="extrachizero" extrachi_cutoff="0"/>
+    <InitializeFromCommandline name="commandline_init"/>
+    <RestrictToRepacking name="restrict_to_repacking"/>
+  </TASKOPERATIONS>
+
+  <FILTERS>
+  </FILTERS>
+
+  <MOVERS>
+    <StoreResidueSubset name="neighbor_shell_storer" subset_name="neighbor_shell" residue_selector="bubble_adjacent" />
+
+    <AddConstraintsToCurrentConformationMover name="addcst" use_distance_cst="1" coord_dev="0.5" min_seq_sep="0" max_distance="9" CA_only="1" bound_width="0.0" cst_weight="0.0"/>
+    <ClearConstraintsMover name="clearcst"/>
+    <MinMover name="minimize" scorefxn="fa_fxn_cst" chi="1" bb="1" type="lbfgs_armijo_nonmonotone" tolerance="%%min_tolerance%%" max_iter="%%min_max_iter%%" abs_score_convergence_threshold="%%min_abs_score_convergence_threshold%%"/>
+
+    <PackRotamersMover name="repack" scorefxn="fa_fxn" task_operations="commandline_init,repackonly,norepack,multicool"/>
+
+    <SavePoseMover name="input_struct_spm" reference_name="input_struct"/>
+    <SavePoseMover name="input_struct_lpm" restore_pose="1" reference_name="input_struct"/>
+    <SavePoseMover name="min_input_struct_spm" reference_name="min_input_struct"/>
+    <SavePoseMover name="min_input_struct_lpm" restore_pose="1" reference_name="min_input_struct"/>
+
+    <ReportToDB name="structreport" batch_description="interface_ddG_struct" database_name="struct.db3">
+      <PoseConformationFeatures/>
+      <PdbDataFeatures/>
+      <JobDataFeatures/>
+      <ResidueFeatures/>
+      <PoseCommentsFeatures/>
+      <ProteinResidueConformationFeatures/>
+      <ResidueConformationFeatures/>
+      <RotamerFeatures/>
+      <ResidueBurialFeatures/>
+      <ProteinRMSDFeatures reference_name="min_input_struct"/>
+    </ReportToDB>
+
+    <ScoreMover name="apply_score" scorefxn="fa_fxn_cst" verbose="0"/>
+
+    <PDBTrajectoryRecorder name="dump_wt_minimized" stride="1" filename="wt_minimized.pdb"/>
+
+    <ParsedProtocol name="finish_wt_post_backrub">
+      <Add mover_name="structreport"/>
+
+      <Add mover_name="repack"/>
+
+      <Add mover_name="addcst"/>
+      <Add mover_name="minimize"/>
+      <Add mover_name="clearcst"/>
+
+      <Add mover_name="structreport"/>
+      <Add mover_name="dump_wt_minimized"/>
+    </ParsedProtocol>
+
+    <BackrubProtocol name="backrub" mc_kt="%%backrub_kt%%" ntrials="%%backrub_trials%%" pivot_residue_selector="restore_neighbor_shell" task_operations="restrict_to_repacking,commandline_init,extrachizero" recover_low="0" trajectory_stride="%%backrub_stride%%" trajectory_apply_mover="finish_wt_post_backrub" trajectory="1" scorefxn="fa_fxn"/>
+
+  </MOVERS>
+  <APPLY_TO_POSE>
+  </APPLY_TO_POSE>
+  <PROTOCOLS>
+    <Add mover_name="input_struct_spm"/>
+    <Add mover_name="addcst"/>
+    <Add mover_name="apply_score"/> <!-- Necessary to initialize neighbor graph -->
+    <Add mover_name="neighbor_shell_storer"/>
+
+    <Add mover_name="minimize"/>
+
+    <Add mover_name="clearcst"/>
+    <Add mover_name="min_input_struct_spm"/>
+
+    <Add mover_name="input_struct_lpm"/>
+    <Add mover_name="structreport"/>
+    <Add mover_name="min_input_struct_lpm"/>
+    <Add mover_name="structreport"/>
+
+    <Add mover_name="backrub"/>
+  </PROTOCOLS>
+  <OUTPUT />
+</ROSETTASCRIPTS>

conf/split_protocol/flex_ddG-mutation_step.xml

@@ -0,0 +1,95 @@
+<ROSETTASCRIPTS>
+  <SCOREFXNS>
+    <ScoreFunction name="fa_fxn" weights="talaris2014"/>
+    <ScoreFunction name="fa_fxn_cst" weights="talaris2014">
+      <Reweight scoretype="atom_pair_constraint" weight="1.0"/>
+      <Set fa_max_dis="9.0"/>
+    </ScoreFunction>
+  </SCOREFXNS>
+
+  <TASKOPERATIONS>
+    <ReadResfile name="res_mutate" filename="%%mutate_resfile_relpath%%"/>
+  </TASKOPERATIONS>
+
+  <RESIDUE_SELECTORS>
+    <Task name="resselector" fixed="0" packable="0" designable="1" task_operations="res_mutate"/>
+    <Neighborhood name="bubble_helper" selector="resselector" distance="%%neighbor_distance%%" include_focus_in_subset="true"/>
+    <NativeSelector name="bubble" residue_selector="bubble_helper" />
+    <PrimarySequenceNeighborhood name="bubble_adjacent" selector="bubble" lower="1" upper="1"/>
+    <StoredResidueSubset name="restore_neighbor_shell" subset_name="neighbor_shell"/>
+    <Not name="everythingelse" selector="restore_neighbor_shell"/>
+  </RESIDUE_SELECTORS>
+  <TASKOPERATIONS>
+    <OperateOnResidueSubset name="repackonly" selector="restore_neighbor_shell">
+      <RestrictToRepackingRLT/>
+    </OperateOnResidueSubset>
+    <OperateOnResidueSubset name="norepack" selector="everythingelse">
+      <PreventRepackingRLT/>
+    </OperateOnResidueSubset>
+    <UseMultiCoolAnnealer name="multicool" states="6"/>
+    <ExtraChiCutoff name="extrachizero" extrachi_cutoff="0"/>
+    <InitializeFromCommandline name="commandline_init"/>
+    <RestrictToRepacking name="restrict_to_repacking"/>
+  </TASKOPERATIONS>
+
+  <MOVERS>
+    <AddConstraintsToCurrentConformationMover name="addcst" use_distance_cst="1" coord_dev="0.5" min_seq_sep="0" max_distance="9" CA_only="1" bound_width="0.0" cst_weight="0.0"/>
+    <ClearConstraintsMover name="clearcst"/>
+    <MinMover name="minimize" scorefxn="fa_fxn_cst" chi="1" bb="1" type="lbfgs_armijo_nonmonotone" tolerance="%%min_tolerance%%" max_iter="%%min_max_iter%%" abs_score_convergence_threshold="%%min_abs_score_convergence_threshold%%"/>
+
+    <PackRotamersMover name="mutate" scorefxn="fa_fxn" task_operations="commandline_init,res_mutate,norepack,multicool"/>
+
+    <ReportToDB name="dbreport" batch_description="interface_ddG" database_name="ddG.db3">
+      <ResidueFeatures/>
+      <ScoreTypeFeatures/>
+      <ScoreFunctionFeatures scorefxn="fa_fxn"/>
+      <StructureScoresFeatures scorefxn="fa_fxn"/>
+      <HBondFeatures scorefxn="fa_fxn"/>
+      <InterfaceFeatures scorefxn="fa_fxn" pack_together="false"/>
+    </ReportToDB>
+
+    <ReportToDB name="structreport" batch_description="interface_ddG_struct" database_name="struct.db3">
+      <PoseConformationFeatures/>
+      <PdbDataFeatures/>
+      <JobDataFeatures/>
+      <ResidueFeatures/>
+      <PoseCommentsFeatures/>
+      <ProteinResidueConformationFeatures/>
+      <ResidueConformationFeatures/>
+      <RotamerFeatures/>
+      <ResidueBurialFeatures/>
+    </ReportToDB>
+
+    <SavePoseMover name="save_wt_bound_pose" restore_pose="0" reference_name="wt_bound_pose"/>
+    <LoadPDB name="load_backrub_pdb" filename="%%backrub_pdb_path%%"/>
+
+    <InterfaceDdGMover name="int_ddG_mover" wt_ref_savepose_mover="save_wt_bound_pose" chain_name="%%chainstomove%%" db_reporter="dbreport" scorefxn="fa_fxn"/>
+
+    <ScoreMover name="apply_score" scorefxn="fa_fxn_cst" verbose="0"/>
+    <StoreResidueSubset name="neighbor_shell_storer" subset_name="neighbor_shell" residue_selector="bubble_adjacent" />
+
+  </MOVERS>
+  <APPLY_TO_POSE>
+  </APPLY_TO_POSE>
+  <PROTOCOLS>
+    <Add mover_name="save_wt_bound_pose"/>
+
+    <Add mover_name="load_backrub_pdb"/>
+    <Add mover_name="neighbor_shell_storer"/>
+
+    <Add mover_name="addcst"/>
+    <Add mover_name="apply_score"/>
+    <Add mover_name="clearcst"/>
+    <Add mover_name="mutate"/>
+
+    <Add mover_name="addcst"/>
+    <Add mover_name="minimize"/>
+    <Add mover_name="clearcst"/>
+    <Add mover_name="structreport"/>
+
+    <Add mover_name="int_ddG_mover"/>
+
+    <Add mover_name="dbreport"/>
+  </PROTOCOLS>
+  <OUTPUT />
+</ROSETTASCRIPTS>

conf/split_protocol/split_commands.txt

@@ -0,0 +1,32 @@
+Backrub step command line example:
+
+rosetta_scripts.linuxgccrelease
+-parser:protocol flex_ddG-backrub_step.xml
+-s wt_pdb_path # Starting WT crystal structure
+-in:file:fullatom
+-parser:script_vars
+mutate_resfile_relpath=%s # Path to a resfile specifying mutant positions. Can be any set of mutations (only the positions matter), as mutations are made in the next step. Positions need to be known now to pick backrub region.
+backrub_kt=1.2
+backrub_trials=36000
+backrub_stride=12000
+neighbor_distance=12.0
+sc_sample_rotwells_unif=0
+min_tolerance=0.000001
+min_max_iter=5000
+min_abs_score_convergence_threshold=1.0
+
+Mutation step command line example:
+
+rosetta_scripts.linuxgccrelease
+-parser:protocol flex_ddG-mutation_step.xml
+-s wt_minimized_pdb_path # Path to the WT minimized PDB structure from the first script, needed to score ddG calculation
+-native # Path to the starting WT crystal structure, needed so that same neighbor residue bubble is selected
+-in:file:fullatom
+-parser:script_vars
+chainstomove=%s
+mutate_resfile_relpath=%s # Path to resfile specifying mutations
+min_tolerance=0.000001
+min_max_iter=5000
+neighbor_distance=12.0
+min_abs_score_convergence_threshold=1.0
+backrub_pdb_path=%s # Path to backrub PDB output from earlier step, mutations will be applied to this model

config.json

@@ -0,0 +1,33 @@
+{
+  "project": "flex_ddG_tutorial",
+  "purpose": "Directory layout metadata only. This file is not used by the runtime scripts.",
+  "layout": {
+    "conf": {
+      "description": "Rosetta XML protocols and related protocol configuration files.",
+      "paths": [
+        "conf/ddG-backrub.xml",
+        "conf/ddG-no_backrub_control.xml",
+        "conf/per_chain_rescore.xml",
+        "conf/split_protocol/",
+        "conf/fig-overview.png"
+      ]
+    },
+    "scripts": {
+      "description": "Python entry points, helper modules, and bundled example input data.",
+      "paths": [
+        "scripts/run_example_1.py",
+        "scripts/run_example_2_saturation.py",
+        "scripts/analyze_flex_ddG.py",
+        "scripts/extract_structures.py",
+        "scripts/inputs/"
+      ]
+    },
+    "root": {
+      "description": "Top-level documentation, license, and static overview assets.",
+      "paths": [
+        "README.md",
+        "LICENSE"
+      ]
+    }
+  }
+}

scripts/analyze_flex_ddG.py

@@ -0,0 +1,344 @@
+#!/usr/bin/python3
+
+import sys
+import os
+import sqlite3
+import shutil
+import tempfile
+from pprint import pprint
+import pandas as pd
+import numpy as np
+import re
+import argparse
+import datetime
+import sys
+import collections
+import threading
+
+import flex_ddg_db3
+
+rosetta_output_file_name = 'rosetta.out'
+output_database_name = 'ddG.db3'
+script_output_folder = 'analysis_output'
+
+# Only a fallback. The stride each run actually used is read back out of its own ddG.db3, so
+# runs with different strides analyze correctly and nothing here needs editing to match a run.
+# This value is used only when the database does not record it, and a warning is printed.
+default_trajectory_stride = 5
+
+zemu_gam_params = {
+    'fa_sol' :      (6.940, -6.722),
+    'hbond_sc' :    (1.902, -1.999),
+    'hbond_bb_sc' : (0.063,  0.452),
+    'fa_rep' :      (1.659, -0.836),
+    'fa_elec' :     (0.697, -0.122),
+    'hbond_lr_bb' : (2.738, -1.179),
+    'fa_atr' :      (2.313, -1.649),
+}
+
+def gam_function(x, score_term = None ):
+    return -1.0 * np.exp( zemu_gam_params[score_term][0] ) + 2.0 * np.exp( zemu_gam_params[score_term][0] ) / ( 1.0 + np.exp( -1.0 * x * np.exp( zemu_gam_params[score_term][1] ) ) )
+
+def apply_zemu_gam(scores):
+    new_columns = list(scores.columns)
+    new_columns.remove('total_score')
+    scores = scores.copy()[ new_columns ]
+    for score_term in zemu_gam_params:
+        assert( score_term in scores.columns )
+        scores[score_term] = scores[score_term].apply( gam_function, score_term = score_term )
+    scores[ 'total_score' ] = scores[ list(zemu_gam_params.keys()) ].sum( axis = 1 )
+    scores[ 'score_function_name' ] = scores[ 'score_function_name' ] + '-gam'
+    return scores
+
+def rosetta_output_succeeded( potential_struct_dir ):
+    path_to_rosetta_output = os.path.join( potential_struct_dir, rosetta_output_file_name )
+    if not os.path.isfile(path_to_rosetta_output):
+        return False
+
+    db3_file = os.path.join( potential_struct_dir, output_database_name )
+    if not os.path.isfile( db3_file ):
+        return False
+
+    success_line_found = False
+    no_more_batches_line_found = False
+    with open( path_to_rosetta_output, 'r' ) as f:
+        for line in f:
+            if line.startswith( 'protocols.jd2.JobDistributor' ) and 'reported success in' in line:
+                success_line_found = True
+            if line.startswith( 'protocols.jd2.JobDistributor' ) and 'no more batches to process' in line:
+                no_more_batches_line_found = True
+
+    return no_more_batches_line_found and success_line_found
+
+def find_finished_jobs( output_folder ):
+    return_dict = {}
+    job_dirs = [ os.path.abspath(os.path.join(output_folder, d)) for d in os.listdir(output_folder) if os.path.isdir( os.path.join(output_folder, d) )]
+    for job_dir in job_dirs:
+        completed_struct_dirs = []
+        for potential_struct_dir in sorted([ os.path.abspath(os.path.join(job_dir, d)) for d in os.listdir(job_dir) if os.path.isdir( os.path.join(job_dir, d) )]):
+            if rosetta_output_succeeded( potential_struct_dir ):
+                completed_struct_dirs.append( potential_struct_dir )
+        return_dict[job_dir] = completed_struct_dirs
+
+    return return_dict
+
+def get_scores_from_db3_file(db3_file, struct_number, case_name, trajectory_stride):
+    conn = sqlite3.connect(db3_file)
+    conn.row_factory = sqlite3.Row
+    c = conn.cursor()
+
+    num_batches = c.execute('SELECT max(batch_id) from batches').fetchone()[0]
+
+    scores = pd.read_sql_query('''
+    SELECT batches.name, structure_scores.struct_id, score_types.score_type_name, structure_scores.score_value, score_function_method_options.score_function_name from structure_scores
+    INNER JOIN batches ON batches.batch_id=structure_scores.batch_id
+    INNER JOIN score_function_method_options ON score_function_method_options.batch_id=batches.batch_id
+    INNER JOIN score_types ON score_types.batch_id=structure_scores.batch_id AND score_types.score_type_id=structure_scores.score_type_id
+    ''', conn)
+
+    def renumber_struct_id( struct_id ):
+        return trajectory_stride * ( 1 + (int(struct_id-1) // num_batches) )
+
+    scores['struct_id'] = scores['struct_id'].apply( renumber_struct_id )
+    scores['name'] = scores['name'].apply( lambda x: x[:-9] if x.endswith('_dbreport') else x )
+    scores = scores.pivot_table( index = ['name', 'struct_id', 'score_function_name'], columns = 'score_type_name', values = 'score_value' ).reset_index()
+    scores.rename( columns = {
+        'name' : 'state',
+        'struct_id' : 'backrub_steps',
+    }, inplace=True)
+    scores['struct_num'] = struct_number
+    scores['case_name'] = case_name
+
+    conn.close()
+
+    return scores
+
+def get_per_chain_scores_from_db3_file(db3_file, struct_number, case_name, trajectory_stride):
+    '''Read the per-chain intramolecular energies written by the per-chain protocol variant
+    (see per_chain_protocol.py). Returns None if the run did not report them.
+
+    Only the unbound states are meaningful here: the chains are 1000 A apart, so there are no
+    cross-chain pair energies and each value is exactly that chain's intramolecular energy. On
+    the bound states the value additionally carries roughly half the interface energy, because
+    Rosetta splits each two-body term between its two residues.
+
+    Note that chain IDs come back lowercased, because Rosetta lowercases database table names.
+    Chain "A" appears here as "a". per_chain_protocol.py refuses to set up a run whose chain IDs
+    differ only by case, so this stays unambiguous.
+    '''
+    conn = sqlite3.connect(db3_file)
+    conn.row_factory = sqlite3.Row
+    c = conn.cursor()
+
+    chain_tables = [ row[0] for row in c.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'chain\\_%\\_energy' ESCAPE '\\'"
+    ).fetchall() ]
+    if len(chain_tables) == 0:
+        conn.close()
+        return None
+
+    num_batches = c.execute('SELECT max(batch_id) from batches').fetchone()[0]
+
+    dfs = []
+    for table in chain_tables:
+        chain = table[len('chain_'):-len('_energy')]
+        df = pd.read_sql_query('''
+        SELECT batches.name, %s.struct_id, %s.total_energy from %s
+        INNER JOIN structures ON structures.struct_id=%s.struct_id
+        INNER JOIN batches ON batches.batch_id=structures.batch_id
+        ''' % (table, table, table, table), conn)
+        df['chain'] = chain
+        dfs.append(df)
+    conn.close()
+
+    scores = pd.concat( dfs )
+    scores['struct_id'] = scores['struct_id'].apply(
+        lambda struct_id: trajectory_stride * ( 1 + (int(struct_id-1) // num_batches) ) )
+    scores['name'] = scores['name'].apply( lambda x: x[:-9] if x.endswith('_dbreport') else x )
+    scores.rename( columns = {
+        'name' : 'state',
+        'struct_id' : 'backrub_steps',
+        'total_energy' : 'intra_energy',
+    }, inplace=True)
+    scores['struct_num'] = struct_number
+    scores['case_name'] = case_name
+
+    return scores
+
+def calc_per_chain_ddg( scores ):
+    '''Per-chain intramolecular ddG, read off the unbound states and averaged over nstruct.'''
+    unbound = scores.loc[ scores['state'].isin(['unbound_wt', 'unbound_mut']) ].copy()
+    if len(unbound) == 0:
+        return None
+
+    wide = unbound.pivot_table(
+        index = ['case_name', 'chain', 'backrub_steps', 'struct_num'],
+        columns = 'state', values = 'intra_energy' ).reset_index()
+    if 'unbound_wt' not in wide.columns or 'unbound_mut' not in wide.columns:
+        return None
+    wide['ddG'] = wide['unbound_mut'] - wide['unbound_wt']
+
+    summary = wide.groupby( ['case_name', 'chain', 'backrub_steps'] ).agg(
+        nstruct = ('ddG', 'size'),
+        wt_intra = ('unbound_wt', 'mean'),
+        mut_intra = ('unbound_mut', 'mean'),
+        ddG = ('ddG', 'mean'),
+        ddG_sd = ('ddG', 'std'),
+    ).reset_index()
+    summary['ddG_sem'] = summary['ddG_sd'] / np.sqrt( summary['nstruct'] )
+    return summary.round(decimals=5)
+
+def resolve_trajectory_stride( db3_file, stride_override = None ):
+    '''Stride to label this database's checkpoints with, preferring what the run recorded.'''
+    if stride_override is not None:
+        return stride_override
+
+    stride = flex_ddg_db3.trajectory_stride_from_db3( db3_file )
+    if stride is not None:
+        return stride
+
+    print( 'WARNING: %s does not record backrub_trajectory_stride; assuming %d.' % (
+        db3_file, default_trajectory_stride ) )
+    print( '         If the run used a different stride, pass --stride to label the' )
+    print( '         checkpoints correctly. This affects labels only, not any energy.' )
+    return default_trajectory_stride
+
+def process_finished_struct( output_path, case_name, stride_override = None ):
+    db3_file = os.path.join( output_path, output_database_name )
+    assert( os.path.isfile( db3_file ) )
+    struct_number = int( os.path.basename(output_path) )
+    trajectory_stride = resolve_trajectory_stride( db3_file, stride_override )
+    scores_df = get_scores_from_db3_file( db3_file, struct_number, case_name, trajectory_stride )
+    per_chain_df = get_per_chain_scores_from_db3_file( db3_file, struct_number, case_name, trajectory_stride )
+
+    return scores_df, per_chain_df
+
+def calc_ddg( scores ):
+    total_structs = np.max( scores['struct_num'] )
+
+    nstructs_to_analyze = set([total_structs])
+    for x in range(10, total_structs):
+        if x % 10 == 0:
+            nstructs_to_analyze.add(x)
+    nstructs_to_analyze = sorted(nstructs_to_analyze)
+
+    all_ddg_scores = []
+    for nstructs in nstructs_to_analyze:
+        ddg_scores = scores.loc[ ((scores['state'] == 'unbound_mut') | (scores['state'] == 'bound_wt')) & (scores['struct_num'] <= nstructs) ].copy()
+        for column in ddg_scores.columns:
+            if column not in ['state', 'case_name', 'backrub_steps', 'struct_num', 'score_function_name']:
+                ddg_scores.loc[:,column] *= -1.0
+        ddg_scores = pd.concat( [ ddg_scores, scores.loc[ ((scores['state'] == 'unbound_wt') | (scores['state'] == 'bound_mut')) & (scores['struct_num'] <= nstructs) ].copy() ] )
+        ddg_scores = ddg_scores.groupby( ['case_name', 'backrub_steps', 'struct_num', 'score_function_name'] ).sum( numeric_only = True ).reset_index()
+
+        if nstructs == total_structs:
+            struct_scores = ddg_scores.copy()
+
+        ddg_scores = ddg_scores.groupby( ['case_name', 'backrub_steps', 'score_function_name'] ).mean( numeric_only = True ).round(decimals=5).reset_index()
+        new_columns = list(ddg_scores.columns.values)
+        new_columns.remove( 'struct_num' )
+        ddg_scores = ddg_scores[new_columns]
+        ddg_scores[ 'scored_state' ] = 'ddG'
+        ddg_scores[ 'nstruct' ] = nstructs
+        all_ddg_scores.append(ddg_scores)
+
+    return (pd.concat(all_ddg_scores), struct_scores)
+
+def calc_dgs( scores ):
+    l = []
+
+    total_structs = np.max( scores['struct_num'] )
+
+    nstructs_to_analyze = set([total_structs])
+    for x in range(10, total_structs):
+        if x % 10 == 0:
+            nstructs_to_analyze.add(x)
+    nstructs_to_analyze = sorted(nstructs_to_analyze)
+
+    for state in ['mut', 'wt']:
+        for nstructs in nstructs_to_analyze:
+            dg_scores = scores.loc[ (scores['state'].str.endswith(state)) & (scores['state'].str.startswith('unbound')) & (scores['struct_num'] <= nstructs) ].copy()
+            for column in dg_scores.columns:
+                if column not in ['state', 'case_name', 'backrub_steps', 'struct_num', 'score_function_name']:
+                    dg_scores.loc[:,column] *= -1.0
+            dg_scores = pd.concat( [ dg_scores, scores.loc[ (scores['state'].str.endswith(state)) & (scores['state'].str.startswith('bound')) & (scores['struct_num'] <= nstructs) ].copy() ] )
+            dg_scores = dg_scores.groupby( ['case_name', 'backrub_steps', 'struct_num', 'score_function_name'] ).sum( numeric_only = True ).reset_index()
+            dg_scores = dg_scores.groupby( ['case_name', 'backrub_steps', 'score_function_name'] ).mean( numeric_only = True ).round(decimals=5).reset_index()
+            new_columns = list(dg_scores.columns.values)
+            new_columns.remove( 'struct_num' )
+            dg_scores = dg_scores[new_columns]
+            dg_scores[ 'scored_state' ] = state + '_dG'
+            dg_scores[ 'nstruct' ] = nstructs
+            l.append( dg_scores )
+    return l
+
+def analyze_output_folder( output_folder, stride_override = None ):
+    # Pass in an outer output folder. Subdirectories are considered different mutation cases, with subdirectories of different structures.
+    finished_jobs = find_finished_jobs( output_folder )
+    if len(finished_jobs) == 0:
+        print( 'No finished jobs found' )
+        return
+
+    ddg_scores_dfs = []
+    struct_scores_dfs = []
+    per_chain_dfs = []
+    for finished_job, finished_structs in finished_jobs.items():
+        inner_scores_list = []
+        inner_per_chain_list = []
+        for finished_struct in finished_structs:
+            inner_scores, inner_per_chain = process_finished_struct( finished_struct, os.path.basename(finished_job), stride_override )
+            inner_scores_list.append( inner_scores )
+            if inner_per_chain is not None:
+                inner_per_chain_list.append( inner_per_chain )
+        scores = pd.concat( inner_scores_list )
+        if len(inner_per_chain_list) > 0:
+            per_chain_summary = calc_per_chain_ddg( pd.concat( inner_per_chain_list ) )
+            if per_chain_summary is not None:
+                per_chain_dfs.append( per_chain_summary )
+        ddg_scores, struct_scores = calc_ddg( scores )
+        struct_scores_dfs.append( struct_scores )
+        ddg_scores_dfs.append( ddg_scores )
+        ddg_scores_dfs.append( apply_zemu_gam(ddg_scores) )
+        ddg_scores_dfs.extend( calc_dgs( scores ) )
+
+    if not os.path.isdir(script_output_folder):
+        os.makedirs(script_output_folder)
+    basename = os.path.basename(output_folder)
+
+    pd.concat( struct_scores_dfs ).to_csv( os.path.join(script_output_folder, basename + '-struct_scores_results.csv' ) )
+
+    df = pd.concat( ddg_scores_dfs )
+    df.to_csv( os.path.join(script_output_folder, basename + '-results.csv') )
+
+    display_columns = ['backrub_steps', 'case_name', 'nstruct', 'score_function_name', 'scored_state', 'total_score']
+    for score_type in ['mut_dG', 'wt_dG', 'ddG']:
+        print( score_type )
+        print( df.loc[ df['scored_state'] == score_type ][display_columns].head( n = 20 ) )
+        print( '' )
+
+    if len(per_chain_dfs) > 0:
+        per_chain = pd.concat( per_chain_dfs )
+        per_chain.to_csv( os.path.join(script_output_folder, basename + '-per_chain_results.csv'), index = False )
+        print( 'per-chain intramolecular ddG (from the unbound states)' )
+        print( per_chain.head( n = 40 ).to_string(index = False) )
+        print( '' )
+        print( 'NOTE: this is the intramolecular strain difference in the *bound* backbone' )
+        print( '      conformation, not a folding ddG -- the unbound state is never relaxed.' )
+        print( '      A chain you did not mutate should come out at ~0 +/- ddG_sem; if it does' )
+        print( '      not, nstruct is too low to average out the whole-pose minimization noise.' )
+        print( '' )
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+        description = 'Analyze one or more flex ddG output folders (e.g. "output").' )
+    parser.add_argument( 'output_folders', nargs = '+', help = 'flex ddG output folder(s)' )
+    parser.add_argument( '--stride', type = int, default = None,
+                         help = 'override backrub_trajectory_stride instead of reading it from'
+                                ' each ddG.db3. Affects checkpoint labels only, not any energy.' )
+    parsed_args = parser.parse_args()
+
+    for folder_to_analyze in parsed_args.output_folders:
+        if os.path.isdir( folder_to_analyze ):
+            analyze_output_folder( folder_to_analyze, parsed_args.stride )
+        else:
+            print( 'ERROR: %s is not a valid directory' % folder_to_analyze )

scripts/extract_structures.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+import argparse
+import functools
+import subprocess
+import re
+import shutil
+import datetime
+import math
+import collections
+import threading
+
+import flex_ddg_db3
+
+use_multiprocessing = False
+if use_multiprocessing:
+    import multiprocessing
+
+# The Reporter class is useful for printing output for tasks which will take a long time
+# Really, you should just use tqdm now, but I used this before I knew about tqdm and it removes a dependency
+
+# Time in seconds function
+# Converts datetime timedelta object to number of seconds
+def ts(td):
+    return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 1e6) / 1e6
+
+def mean(l):
+    # Not using numpy mean to avoid dependency
+    return float( sum(l) ) / float( len(l) )
+
+class Reporter:
+    def __init__( self, task, entries = 'files', print_output = True, eol_char = '\r' ):
+        self._lock = threading.Lock()
+        self.print_output = print_output
+        self.start = datetime.datetime.now()
+        self.entries = entries
+        self.lastreport = self.start
+        self.task = task
+        self.report_interval = datetime.timedelta( seconds = 1 ) # Interval to print progress
+        self.n = 0
+        self.completion_time = None
+        if self.print_output:
+            print('\nStarting ' + task)
+        self.total_count = None # Total tasks to be processed
+        self.maximum_output_string_length = 0
+        self.rolling_est_total_time = collections.deque( maxlen = 50 )
+        self.kv_callback_results = {}
+        self.list_results = []
+        self.eol_char = eol_char
+
+    def set_total_count(self, x):
+        self.total_count = x
+        self.rolling_est_total_time = collections.deque( maxlen = max(1, int( .05 * x )) )
+
+    def decrement_total_count(self):
+        if self.total_count:
+            self.total_count -= 1
+
+    def report(self, n):
+        with self._lock:
+            self.n = n
+            time_now = datetime.datetime.now()
+            if self.print_output and self.lastreport < (time_now - self.report_interval):
+                self.lastreport = time_now
+                if self.total_count:
+                    percent_done = float(self.n) / float(self.total_count)
+                    est_total_time_seconds = ts(time_now - self.start) * (1.0 / percent_done)
+                    self.rolling_est_total_time.append( est_total_time_seconds )
+                    est_total_time = datetime.timedelta( seconds = mean(self.rolling_est_total_time) )
+                    time_remaining = est_total_time - (time_now - self.start)
+                    eta = time_now + time_remaining
+                    time_remaining_str = 'ETA: %s Est. time remaining: ' % eta.strftime("%Y-%m-%d %H:%M:%S")
+
+                    time_remaining_str += str( datetime.timedelta( seconds = int(ts(time_remaining)) ) )
+
+                    output_string = "  Processed: %d %s (%.1f%%) %s" % (n, self.entries, percent_done*100.0, time_remaining_str)
+                else:
+                    output_string = "  Processed: %d %s" % (n, self.entries)
+
+                output_string += self.eol_char
+
+                if len(output_string) > self.maximum_output_string_length:
+                    self.maximum_output_string_length = len(output_string)
+                elif len(output_string) < self.maximum_output_string_length:
+                    output_string = output_string.ljust(self.maximum_output_string_length)
+                sys.stdout.write( output_string )
+                sys.stdout.flush()
+
+    def increment_report(self):
+        self.report(self.n + 1)
+
+    def increment_report_callback(self, cb_value):
+        self.increment_report()
+
+    def increment_report_keyval_callback(self, kv_pair):
+        key, value = kv_pair
+        self.kv_callback_results[key] = value
+        self.increment_report()
+
+    def increment_report_list_callback(self, new_list_items):
+        self.list_results.extend(new_list_items)
+        self.increment_report()
+
+    def decrement_report(self):
+        self.report(self.n - 1)
+
+    def add_to_report(self, x):
+        self.report(self.n + x)
+
+    def done(self):
+        self.completion_time = datetime.datetime.now()
+        if self.print_output:
+            print('Done %s, processed %d %s, took %s\n' % (self.task, self.n, self.entries, self.completion_time-self.start))
+
+    def elapsed_time(self):
+        if self.completion_time:
+            return self.completion_time - self.start
+        else:
+            return datetime.datetime.now() - self.start
+
+
+struct_db3_file = 'struct.db3'
+
+# Extraction uses the score_jd2 binary, not rosetta_scripts. It is built alongside
+# rosetta_scripts by the standard Rosetta build, but is a separate executable.
+#score_jd2_path = os.path.expanduser( '~/rosetta/source/bin/score_jd2' )
+score_jd2_path = os.path.expanduser(
+"/public/home/scnb9biwet/jiangqq/flex_ddG_tutorial-master/software/rosetta3.9/main/source/bin/score_jd2.default.linuxgccrelease"
+)
+# Only a fallback. Extracted structures are named by how many backrub steps produced them, so
+# the stride each run used is read back out of its own struct.db3. This value is used only when
+# the database does not record it, and a warning is printed.
+default_trajectory_stride = 5
+
+def resolve_trajectory_stride( struct_db, stride_override = None ):
+    '''Stride to name this database's extracted PDBs with, preferring what the run recorded.'''
+    if stride_override is not None:
+        return stride_override
+
+    stride = flex_ddg_db3.trajectory_stride_from_db3( struct_db )
+    if stride is not None:
+        return stride
+
+    print( 'WARNING: %s does not record backrub_trajectory_stride; assuming %d.' % (
+        struct_db, default_trajectory_stride ) )
+    print( '         If the run used a different stride, pass --stride, or the extracted PDBs' )
+    print( '         will be named with the wrong backrub step counts.' )
+    return default_trajectory_stride
+
+def recursive_find_struct_dbs( input_dir ):
+    return_list = []
+
+    for path in [os.path.join(input_dir, x) for x in os.listdir( input_dir )]:
+        if os.path.isdir( path ):
+            return_list.extend( recursive_find_struct_dbs( path ) )
+        elif os.path.isfile( path ) and os.path.basename( path ) == struct_db3_file:
+            return_list.append( path )
+
+    return return_list
+
+def extract_structures( struct_db, rename_function = None ):
+    args = [
+        os.path.abspath( score_jd2_path ),
+        '-inout:dbms:database_name', struct_db3_file,
+        '-in:use_database',
+        '-out:pdb',
+    ]
+
+    working_directory = os.path.dirname( struct_db )
+    rosetta_outfile_path = os.path.join(working_directory, 'structure_output.txt' )
+    if not use_multiprocessing:
+        print(rosetta_outfile_path)
+    rosetta_outfile = open( rosetta_outfile_path, 'w')
+    if not use_multiprocessing:
+        print( ' '.join( args ) )
+    # No shell: joining the arguments into a string breaks as soon as a path contains a space.
+    rosetta_process = subprocess.Popen(
+        args,
+        stdout=rosetta_outfile, stderr=subprocess.STDOUT, close_fds = True, cwd = working_directory,
+    )
+    return_code = rosetta_process.wait()
+    rosetta_outfile.close()
+
+    if return_code == 0:
+        os.remove( rosetta_outfile_path )
+    else:
+        print( 'ERROR: score_jd2 failed on %s (exit %d) -- see %s' % (
+            struct_db, return_code, rosetta_outfile_path ) )
+        return return_code
+
+    if rename_function != None:
+        for path in [ os.path.join( working_directory, x ) for x in os.listdir( working_directory ) ]:
+            m = re.match( r'(\d+)_0001\.pdb$', os.path.basename(path) )
+            if m:
+                dest_path = os.path.join( working_directory, rename_function( int(m.group(1)) ) )
+                shutil.move( path, dest_path )
+
+    return return_code
+
+def flex_ddG_rename(struct_id, trajectory_stride):
+    steps = [
+        'backrub',
+        'wt',
+        'mut',
+    ]
+
+    return '%s_%05d.pdb' % ( steps[ (struct_id-1) % len(steps) ], (((struct_id-1) // len(steps)) + 1) * trajectory_stride )
+
+def main( input_dir, stride_override = None ):
+    struct_dbs = recursive_find_struct_dbs( input_dir )
+    print( 'Found {:d} structure database files to extract'.format( len(struct_dbs) ) )
+
+    if use_multiprocessing:
+        pool = multiprocessing.Pool()
+    r = Reporter('extracting structure database files', entries = '.db3 files')
+    r.set_total_count( len(struct_dbs) )
+
+    for struct_db in struct_dbs:
+        # Each database is named using the stride its own run was launched with.
+        # functools.partial rather than a lambda, so that this stays picklable for the
+        # multiprocessing path below.
+        stride = resolve_trajectory_stride( struct_db, stride_override )
+        rename_function = functools.partial( flex_ddG_rename, trajectory_stride = stride )
+        if use_multiprocessing:
+            pool.apply_async(
+                extract_structures,
+                args = (struct_db,),
+                kwds = {'rename_function' : rename_function},
+                callback = r.increment_report_callback
+            )
+        else:
+            r.increment_report_callback(
+                extract_structures( struct_db, rename_function = rename_function )
+            )
+
+    if use_multiprocessing:
+        pool.close()
+        pool.join()
+    r.done()
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+        description = 'Extract PDBs from the struct.db3 files under a flex ddG output folder.' )
+    parser.add_argument( 'output_folders', nargs = '+', help = 'flex ddG output folder(s)' )
+    parser.add_argument( '--stride', type = int, default = None,
+                         help = 'override backrub_trajectory_stride instead of reading it from'
+                                ' each struct.db3. Affects extracted PDB names only.' )
+    parsed_args = parser.parse_args()
+
+    if not os.path.isfile( score_jd2_path ):
+        print( 'ERROR: "score_jd2_path" variable must be set to the location of the "score_jd2" binary executable' )
+        print( 'This file might look something like: "score_jd2.linuxgccrelease"' )
+        print( 'Note that this is a different executable from the "rosetta_scripts" binary used to run flex ddG' )
+        raise Exception( 'score_jd2 missing' )
+
+    for x in parsed_args.output_folders:
+        if os.path.isdir(x):
+            main( x, parsed_args.stride )
+        else:
+            print( 'ERROR: %s is not a valid directory' % x )

scripts/flex_ddg_db3.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+
+'''Small helpers shared by analyze_flex_ddG.py and extract_structures.py.
+
+Standard library only, so that extract_structures.py keeps running without numpy or pandas.
+'''
+
+import re
+import sqlite3
+
+# Rosetta records the full option list it was invoked with in the "protocols" table of every
+# features database it writes, so the stride a run actually used can be read back out of the
+# output instead of being remembered and re-typed by hand.
+_stride_re = re.compile( r'backrub_trajectory_stride[= ]+(\d+)' )
+
+def trajectory_stride_from_db3( db3_file ):
+    '''The backrub_trajectory_stride the run in db3_file was launched with.
+
+    Returns None if it cannot be determined, which happens for databases written by Rosetta
+    versions that predate the protocols table, or if the stride was left at the XML default
+    instead of being passed on the command line. Callers should fall back to a default and say
+    so, because the stride does not affect any energy -- it only labels the checkpoints, so a
+    wrong value silently mislabels every row (and misnames every extracted PDB) rather than
+    causing a visible failure.
+    '''
+    try:
+        conn = sqlite3.connect( 'file:%s?mode=ro' % db3_file, uri = True )
+    except sqlite3.Error:
+        return None
+
+    try:
+        try:
+            rows = conn.execute( 'SELECT specified_options, command_line FROM protocols' ).fetchall()
+        except sqlite3.Error:
+            return None
+
+        strides = set()
+        for row in rows:
+            for field in row:
+                if field:
+                    strides.update( int(m) for m in _stride_re.findall( field ) )
+    finally:
+        conn.close()
+
+    # More than one distinct value means the database mixes runs; we cannot label it correctly.
+    if len( strides ) == 1:
+        return strides.pop()
+    return None

scripts/inputs/1JTG/chains_to_move.txt

@@ -0,0 +1 @@
+B

scripts/inputs/1JTG/mutations.mutfile

@@ -0,0 +1,6 @@
+total 4
+4
+N 351 K
+D 397 K
+D 425 K
+V 427 K

scripts/inputs/1JTG/mutations.resfile

@@ -0,0 +1,6 @@
+NATRO
+start
+135 B PIKAA K
+163 B PIKAA K
+165 B PIKAA K
+89 B PIKAA K

scripts/inputs/1JTG/nataa_mutations.resfile

@@ -0,0 +1,6 @@
+NATAA
+start
+135 B PIKAA K
+163 B PIKAA K
+165 B PIKAA K
+89 B PIKAA K

scripts/inputs/1JTG/pdb2rosetta.resmap.json

@@ -0,0 +1,429 @@
+{
+"A  26 ": 1,
+"A  27 ": 2,
+"A  28 ": 3,
+"A  29 ": 4,
+"A  30 ": 5,
+"A  31 ": 6,
+"A  32 ": 7,
+"A  33 ": 8,
+"A  34 ": 9,
+"A  35 ": 10,
+"A  36 ": 11,
+"A  37 ": 12,
+"A  38 ": 13,
+"A  39 ": 14,
+"A  40 ": 15,
+"A  41 ": 16,
+"A  42 ": 17,
+"A  43 ": 18,
+"A  44 ": 19,
+"A  45 ": 20,
+"A  46 ": 21,
+"A  47 ": 22,
+"A  48 ": 23,
+"A  49 ": 24,
+"A  50 ": 25,
+"A  51 ": 26,
+"A  52 ": 27,
+"A  53 ": 28,
+"A  54 ": 29,
+"A  55 ": 30,
+"A  56 ": 31,
+"A  57 ": 32,
+"A  58 ": 33,
+"A  59 ": 34,
+"A  60 ": 35,
+"A  61 ": 36,
+"A  62 ": 37,
+"A  63 ": 38,
+"A  64 ": 39,
+"A  65 ": 40,
+"A  66 ": 41,
+"A  67 ": 42,
+"A  68 ": 43,
+"A  69 ": 44,
+"A  70 ": 45,
+"A  71 ": 46,
+"A  72 ": 47,
+"A  73 ": 48,
+"A  74 ": 49,
+"A  75 ": 50,
+"A  76 ": 51,
+"A  77 ": 52,
+"A  78 ": 53,
+"A  79 ": 54,
+"A  80 ": 55,
+"A  81 ": 56,
+"A  82 ": 57,
+"A  83 ": 58,
+"A  84 ": 59,
+"A  85 ": 60,
+"A  86 ": 61,
+"A  87 ": 62,
+"A  88 ": 63,
+"A  89 ": 64,
+"A  90 ": 65,
+"A  91 ": 66,
+"A  92 ": 67,
+"A  93 ": 68,
+"A  94 ": 69,
+"A  95 ": 70,
+"A  96 ": 71,
+"A  97 ": 72,
+"A  98 ": 73,
+"A  99 ": 74,
+"A 100 ": 75,
+"A 101 ": 76,
+"A 102 ": 77,
+"A 103 ": 78,
+"A 104 ": 79,
+"A 105 ": 80,
+"A 106 ": 81,
+"A 107 ": 82,
+"A 108 ": 83,
+"A 109 ": 84,
+"A 110 ": 85,
+"A 111 ": 86,
+"A 112 ": 87,
+"A 113 ": 88,
+"A 114 ": 89,
+"A 115 ": 90,
+"A 116 ": 91,
+"A 117 ": 92,
+"A 118 ": 93,
+"A 119 ": 94,
+"A 120 ": 95,
+"A 121 ": 96,
+"A 122 ": 97,
+"A 123 ": 98,
+"A 124 ": 99,
+"A 125 ": 100,
+"A 126 ": 101,
+"A 127 ": 102,
+"A 128 ": 103,
+"A 129 ": 104,
+"A 130 ": 105,
+"A 131 ": 106,
+"A 132 ": 107,
+"A 133 ": 108,
+"A 134 ": 109,
+"A 135 ": 110,
+"A 136 ": 111,
+"A 137 ": 112,
+"A 138 ": 113,
+"A 139 ": 114,
+"A 140 ": 115,
+"A 141 ": 116,
+"A 142 ": 117,
+"A 143 ": 118,
+"A 144 ": 119,
+"A 145 ": 120,
+"A 146 ": 121,
+"A 147 ": 122,
+"A 148 ": 123,
+"A 149 ": 124,
+"A 150 ": 125,
+"A 151 ": 126,
+"A 152 ": 127,
+"A 153 ": 128,
+"A 154 ": 129,
+"A 155 ": 130,
+"A 156 ": 131,
+"A 157 ": 132,
+"A 158 ": 133,
+"A 159 ": 134,
+"A 160 ": 135,
+"A 161 ": 136,
+"A 162 ": 137,
+"A 163 ": 138,
+"A 164 ": 139,
+"A 165 ": 140,
+"A 166 ": 141,
+"A 167 ": 142,
+"A 168 ": 143,
+"A 169 ": 144,
+"A 170 ": 145,
+"A 171 ": 146,
+"A 172 ": 147,
+"A 173 ": 148,
+"A 174 ": 149,
+"A 175 ": 150,
+"A 176 ": 151,
+"A 177 ": 152,
+"A 178 ": 153,
+"A 179 ": 154,
+"A 180 ": 155,
+"A 181 ": 156,
+"A 182 ": 157,
+"A 183 ": 158,
+"A 184 ": 159,
+"A 185 ": 160,
+"A 186 ": 161,
+"A 187 ": 162,
+"A 188 ": 163,
+"A 189 ": 164,
+"A 190 ": 165,
+"A 191 ": 166,
+"A 192 ": 167,
+"A 193 ": 168,
+"A 194 ": 169,
+"A 195 ": 170,
+"A 196 ": 171,
+"A 197 ": 172,
+"A 198 ": 173,
+"A 199 ": 174,
+"A 200 ": 175,
+"A 201 ": 176,
+"A 202 ": 177,
+"A 203 ": 178,
+"A 204 ": 179,
+"A 205 ": 180,
+"A 206 ": 181,
+"A 207 ": 182,
+"A 208 ": 183,
+"A 209 ": 184,
+"A 210 ": 185,
+"A 211 ": 186,
+"A 212 ": 187,
+"A 213 ": 188,
+"A 215 ": 189,
+"A 216 ": 190,
+"A 217 ": 191,
+"A 218 ": 192,
+"A 219 ": 193,
+"A 220 ": 194,
+"A 221 ": 195,
+"A 222 ": 196,
+"A 223 ": 197,
+"A 224 ": 198,
+"A 225 ": 199,
+"A 226 ": 200,
+"A 227 ": 201,
+"A 228 ": 202,
+"A 229 ": 203,
+"A 230 ": 204,
+"A 231 ": 205,
+"A 232 ": 206,
+"A 233 ": 207,
+"A 234 ": 208,
+"A 235 ": 209,
+"A 236 ": 210,
+"A 237 ": 211,
+"A 238 ": 212,
+"A 239 ": 213,
+"A 240 ": 214,
+"A 241 ": 215,
+"A 242 ": 216,
+"A 243 ": 217,
+"A 244 ": 218,
+"A 245 ": 219,
+"A 246 ": 220,
+"A 247 ": 221,
+"A 248 ": 222,
+"A 249 ": 223,
+"A 250 ": 224,
+"A 251 ": 225,
+"A 252 ": 226,
+"A 253 ": 227,
+"A 254 ": 228,
+"A 255 ": 229,
+"A 256 ": 230,
+"A 257 ": 231,
+"A 258 ": 232,
+"A 259 ": 233,
+"A 260 ": 234,
+"A 261 ": 235,
+"A 262 ": 236,
+"A 263 ": 237,
+"A 264 ": 238,
+"A 265 ": 239,
+"A 266 ": 240,
+"A 267 ": 241,
+"A 268 ": 242,
+"A 269 ": 243,
+"A 270 ": 244,
+"A 271 ": 245,
+"A 272 ": 246,
+"A 273 ": 247,
+"A 274 ": 248,
+"A 275 ": 249,
+"A 276 ": 250,
+"A 277 ": 251,
+"A 278 ": 252,
+"A 279 ": 253,
+"A 280 ": 254,
+"A 281 ": 255,
+"A 282 ": 256,
+"A 283 ": 257,
+"A 284 ": 258,
+"A 285 ": 259,
+"A 286 ": 260,
+"A 287 ": 261,
+"A 288 ": 262,
+"B   1 ": 263,
+"B   2 ": 264,
+"B   3 ": 265,
+"B   4 ": 266,
+"B   5 ": 267,
+"B   6 ": 268,
+"B   7 ": 269,
+"B   8 ": 270,
+"B   9 ": 271,
+"B  10 ": 272,
+"B  11 ": 273,
+"B  12 ": 274,
+"B  13 ": 275,
+"B  14 ": 276,
+"B  15 ": 277,
+"B  16 ": 278,
+"B  17 ": 279,
+"B  18 ": 280,
+"B  19 ": 281,
+"B  20 ": 282,
+"B  21 ": 283,
+"B  22 ": 284,
+"B  23 ": 285,
+"B  24 ": 286,
+"B  25 ": 287,
+"B  26 ": 288,
+"B  27 ": 289,
+"B  28 ": 290,
+"B  29 ": 291,
+"B  30 ": 292,
+"B  31 ": 293,
+"B  32 ": 294,
+"B  33 ": 295,
+"B  34 ": 296,
+"B  35 ": 297,
+"B  36 ": 298,
+"B  37 ": 299,
+"B  38 ": 300,
+"B  39 ": 301,
+"B  40 ": 302,
+"B  41 ": 303,
+"B  42 ": 304,
+"B  43 ": 305,
+"B  44 ": 306,
+"B  45 ": 307,
+"B  46 ": 308,
+"B  47 ": 309,
+"B  48 ": 310,
+"B  49 ": 311,
+"B  50 ": 312,
+"B  51 ": 313,
+"B  52 ": 314,
+"B  53 ": 315,
+"B  54 ": 316,
+"B  55 ": 317,
+"B  56 ": 318,
+"B  57 ": 319,
+"B  58 ": 320,
+"B  59 ": 321,
+"B  60 ": 322,
+"B  61 ": 323,
+"B  62 ": 324,
+"B  63 ": 325,
+"B  64 ": 326,
+"B  65 ": 327,
+"B  66 ": 328,
+"B  67 ": 329,
+"B  68 ": 330,
+"B  69 ": 331,
+"B  70 ": 332,
+"B  71 ": 333,
+"B  72 ": 334,
+"B  73 ": 335,
+"B  74 ": 336,
+"B  75 ": 337,
+"B  76 ": 338,
+"B  77 ": 339,
+"B  78 ": 340,
+"B  79 ": 341,
+"B  80 ": 342,
+"B  81 ": 343,
+"B  82 ": 344,
+"B  83 ": 345,
+"B  84 ": 346,
+"B  85 ": 347,
+"B  86 ": 348,
+"B  87 ": 349,
+"B  88 ": 350,
+"B  89 ": 351,
+"B  90 ": 352,
+"B  91 ": 353,
+"B  92 ": 354,
+"B  93 ": 355,
+"B  94 ": 356,
+"B  95 ": 357,
+"B  96 ": 358,
+"B  97 ": 359,
+"B  98 ": 360,
+"B  99 ": 361,
+"B 100 ": 362,
+"B 101 ": 363,
+"B 102 ": 364,
+"B 103 ": 365,
+"B 104 ": 366,
+"B 105 ": 367,
+"B 106 ": 368,
+"B 107 ": 369,
+"B 108 ": 370,
+"B 109 ": 371,
+"B 110 ": 372,
+"B 111 ": 373,
+"B 112 ": 374,
+"B 113 ": 375,
+"B 114 ": 376,
+"B 115 ": 377,
+"B 116 ": 378,
+"B 117 ": 379,
+"B 118 ": 380,
+"B 119 ": 381,
+"B 120 ": 382,
+"B 121 ": 383,
+"B 122 ": 384,
+"B 123 ": 385,
+"B 124 ": 386,
+"B 125 ": 387,
+"B 126 ": 388,
+"B 127 ": 389,
+"B 128 ": 390,
+"B 129 ": 391,
+"B 130 ": 392,
+"B 131 ": 393,
+"B 132 ": 394,
+"B 133 ": 395,
+"B 134 ": 396,
+"B 135 ": 397,
+"B 136 ": 398,
+"B 137 ": 399,
+"B 138 ": 400,
+"B 139 ": 401,
+"B 140 ": 402,
+"B 141 ": 403,
+"B 142 ": 404,
+"B 143 ": 405,
+"B 144 ": 406,
+"B 145 ": 407,
+"B 146 ": 408,
+"B 147 ": 409,
+"B 148 ": 410,
+"B 149 ": 411,
+"B 150 ": 412,
+"B 151 ": 413,
+"B 152 ": 414,
+"B 153 ": 415,
+"B 154 ": 416,
+"B 155 ": 417,
+"B 156 ": 418,
+"B 157 ": 419,
+"B 158 ": 420,
+"B 159 ": 421,
+"B 160 ": 422,
+"B 161 ": 423,
+"B 162 ": 424,
+"B 163 ": 425,
+"B 164 ": 426,
+"B 165 ": 427
+}

scripts/inputs/1JTG/rosetta2pdb.resmap.json

@@ -0,0 +1,429 @@
+{
+"1": "A  26 ",
+"2": "A  27 ",
+"3": "A  28 ",
+"4": "A  29 ",
+"5": "A  30 ",
+"6": "A  31 ",
+"7": "A  32 ",
+"8": "A  33 ",
+"9": "A  34 ",
+"10": "A  35 ",
+"11": "A  36 ",
+"12": "A  37 ",
+"13": "A  38 ",
+"14": "A  39 ",
+"15": "A  40 ",
+"16": "A  41 ",
+"17": "A  42 ",
+"18": "A  43 ",
+"19": "A  44 ",
+"20": "A  45 ",
+"21": "A  46 ",
+"22": "A  47 ",
+"23": "A  48 ",
+"24": "A  49 ",
+"25": "A  50 ",
+"26": "A  51 ",
+"27": "A  52 ",
+"28": "A  53 ",
+"29": "A  54 ",
+"30": "A  55 ",
+"31": "A  56 ",
+"32": "A  57 ",
+"33": "A  58 ",
+"34": "A  59 ",
+"35": "A  60 ",
+"36": "A  61 ",
+"37": "A  62 ",
+"38": "A  63 ",
+"39": "A  64 ",
+"40": "A  65 ",
+"41": "A  66 ",
+"42": "A  67 ",
+"43": "A  68 ",
+"44": "A  69 ",
+"45": "A  70 ",
+"46": "A  71 ",
+"47": "A  72 ",
+"48": "A  73 ",
+"49": "A  74 ",
+"50": "A  75 ",
+"51": "A  76 ",
+"52": "A  77 ",
+"53": "A  78 ",
+"54": "A  79 ",
+"55": "A  80 ",
+"56": "A  81 ",
+"57": "A  82 ",
+"58": "A  83 ",
+"59": "A  84 ",
+"60": "A  85 ",
+"61": "A  86 ",
+"62": "A  87 ",
+"63": "A  88 ",
+"64": "A  89 ",
+"65": "A  90 ",
+"66": "A  91 ",
+"67": "A  92 ",
+"68": "A  93 ",
+"69": "A  94 ",
+"70": "A  95 ",
+"71": "A  96 ",
+"72": "A  97 ",
+"73": "A  98 ",
+"74": "A  99 ",
+"75": "A 100 ",
+"76": "A 101 ",
+"77": "A 102 ",
+"78": "A 103 ",
+"79": "A 104 ",
+"80": "A 105 ",
+"81": "A 106 ",
+"82": "A 107 ",
+"83": "A 108 ",
+"84": "A 109 ",
+"85": "A 110 ",
+"86": "A 111 ",
+"87": "A 112 ",
+"88": "A 113 ",
+"89": "A 114 ",
+"90": "A 115 ",
+"91": "A 116 ",
+"92": "A 117 ",
+"93": "A 118 ",
+"94": "A 119 ",
+"95": "A 120 ",
+"96": "A 121 ",
+"97": "A 122 ",
+"98": "A 123 ",
+"99": "A 124 ",
+"100": "A 125 ",
+"101": "A 126 ",
+"102": "A 127 ",
+"103": "A 128 ",
+"104": "A 129 ",
+"105": "A 130 ",
+"106": "A 131 ",
+"107": "A 132 ",
+"108": "A 133 ",
+"109": "A 134 ",
+"110": "A 135 ",
+"111": "A 136 ",
+"112": "A 137 ",
+"113": "A 138 ",
+"114": "A 139 ",
+"115": "A 140 ",
+"116": "A 141 ",
+"117": "A 142 ",
+"118": "A 143 ",
+"119": "A 144 ",
+"120": "A 145 ",
+"121": "A 146 ",
+"122": "A 147 ",
+"123": "A 148 ",
+"124": "A 149 ",
+"125": "A 150 ",
+"126": "A 151 ",
+"127": "A 152 ",
+"128": "A 153 ",
+"129": "A 154 ",
+"130": "A 155 ",
+"131": "A 156 ",
+"132": "A 157 ",
+"133": "A 158 ",
+"134": "A 159 ",
+"135": "A 160 ",
+"136": "A 161 ",
+"137": "A 162 ",
+"138": "A 163 ",
+"139": "A 164 ",
+"140": "A 165 ",
+"141": "A 166 ",
+"142": "A 167 ",
+"143": "A 168 ",
+"144": "A 169 ",
+"145": "A 170 ",
+"146": "A 171 ",
+"147": "A 172 ",
+"148": "A 173 ",
+"149": "A 174 ",
+"150": "A 175 ",
+"151": "A 176 ",
+"152": "A 177 ",
+"153": "A 178 ",
+"154": "A 179 ",
+"155": "A 180 ",
+"156": "A 181 ",
+"157": "A 182 ",
+"158": "A 183 ",
+"159": "A 184 ",
+"160": "A 185 ",
+"161": "A 186 ",
+"162": "A 187 ",
+"163": "A 188 ",
+"164": "A 189 ",
+"165": "A 190 ",
+"166": "A 191 ",
+"167": "A 192 ",
+"168": "A 193 ",
+"169": "A 194 ",
+"170": "A 195 ",
+"171": "A 196 ",
+"172": "A 197 ",
+"173": "A 198 ",
+"174": "A 199 ",
+"175": "A 200 ",
+"176": "A 201 ",
+"177": "A 202 ",
+"178": "A 203 ",
+"179": "A 204 ",
+"180": "A 205 ",
+"181": "A 206 ",
+"182": "A 207 ",
+"183": "A 208 ",
+"184": "A 209 ",
+"185": "A 210 ",
+"186": "A 211 ",
+"187": "A 212 ",
+"188": "A 213 ",
+"189": "A 215 ",
+"190": "A 216 ",
+"191": "A 217 ",
+"192": "A 218 ",
+"193": "A 219 ",
+"194": "A 220 ",
+"195": "A 221 ",
+"196": "A 222 ",
+"197": "A 223 ",
+"198": "A 224 ",
+"199": "A 225 ",
+"200": "A 226 ",
+"201": "A 227 ",
+"202": "A 228 ",
+"203": "A 229 ",
+"204": "A 230 ",
+"205": "A 231 ",
+"206": "A 232 ",
+"207": "A 233 ",
+"208": "A 234 ",
+"209": "A 235 ",
+"210": "A 236 ",
+"211": "A 237 ",
+"212": "A 238 ",
+"213": "A 239 ",
+"214": "A 240 ",
+"215": "A 241 ",
+"216": "A 242 ",
+"217": "A 243 ",
+"218": "A 244 ",
+"219": "A 245 ",
+"220": "A 246 ",
+"221": "A 247 ",
+"222": "A 248 ",
+"223": "A 249 ",
+"224": "A 250 ",
+"225": "A 251 ",
+"226": "A 252 ",
+"227": "A 253 ",
+"228": "A 254 ",
+"229": "A 255 ",
+"230": "A 256 ",
+"231": "A 257 ",
+"232": "A 258 ",
+"233": "A 259 ",
+"234": "A 260 ",
+"235": "A 261 ",
+"236": "A 262 ",
+"237": "A 263 ",
+"238": "A 264 ",
+"239": "A 265 ",
+"240": "A 266 ",
+"241": "A 267 ",
+"242": "A 268 ",
+"243": "A 269 ",
+"244": "A 270 ",
+"245": "A 271 ",
+"246": "A 272 ",
+"247": "A 273 ",
+"248": "A 274 ",
+"249": "A 275 ",
+"250": "A 276 ",
+"251": "A 277 ",
+"252": "A 278 ",
+"253": "A 279 ",
+"254": "A 280 ",
+"255": "A 281 ",
+"256": "A 282 ",
+"257": "A 283 ",
+"258": "A 284 ",
+"259": "A 285 ",
+"260": "A 286 ",
+"261": "A 287 ",
+"262": "A 288 ",
+"263": "B   1 ",
+"264": "B   2 ",
+"265": "B   3 ",
+"266": "B   4 ",
+"267": "B   5 ",
+"268": "B   6 ",
+"269": "B   7 ",
+"270": "B   8 ",
+"271": "B   9 ",
+"272": "B  10 ",
+"273": "B  11 ",
+"274": "B  12 ",
+"275": "B  13 ",
+"276": "B  14 ",
+"277": "B  15 ",
+"278": "B  16 ",
+"279": "B  17 ",
+"280": "B  18 ",
+"281": "B  19 ",
+"282": "B  20 ",
+"283": "B  21 ",
+"284": "B  22 ",
+"285": "B  23 ",
+"286": "B  24 ",
+"287": "B  25 ",
+"288": "B  26 ",
+"289": "B  27 ",
+"290": "B  28 ",
+"291": "B  29 ",
+"292": "B  30 ",
+"293": "B  31 ",
+"294": "B  32 ",
+"295": "B  33 ",
+"296": "B  34 ",
+"297": "B  35 ",
+"298": "B  36 ",
+"299": "B  37 ",
+"300": "B  38 ",
+"301": "B  39 ",
+"302": "B  40 ",
+"303": "B  41 ",
+"304": "B  42 ",
+"305": "B  43 ",
+"306": "B  44 ",
+"307": "B  45 ",
+"308": "B  46 ",
+"309": "B  47 ",
+"310": "B  48 ",
+"311": "B  49 ",
+"312": "B  50 ",
+"313": "B  51 ",
+"314": "B  52 ",
+"315": "B  53 ",
+"316": "B  54 ",
+"317": "B  55 ",
+"318": "B  56 ",
+"319": "B  57 ",
+"320": "B  58 ",
+"321": "B  59 ",
+"322": "B  60 ",
+"323": "B  61 ",
+"324": "B  62 ",
+"325": "B  63 ",
+"326": "B  64 ",
+"327": "B  65 ",
+"328": "B  66 ",
+"329": "B  67 ",
+"330": "B  68 ",
+"331": "B  69 ",
+"332": "B  70 ",
+"333": "B  71 ",
+"334": "B  72 ",
+"335": "B  73 ",
+"336": "B  74 ",
+"337": "B  75 ",
+"338": "B  76 ",
+"339": "B  77 ",
+"340": "B  78 ",
+"341": "B  79 ",
+"342": "B  80 ",
+"343": "B  81 ",
+"344": "B  82 ",
+"345": "B  83 ",
+"346": "B  84 ",
+"347": "B  85 ",
+"348": "B  86 ",
+"349": "B  87 ",
+"350": "B  88 ",
+"351": "B  89 ",
+"352": "B  90 ",
+"353": "B  91 ",
+"354": "B  92 ",
+"355": "B  93 ",
+"356": "B  94 ",
+"357": "B  95 ",
+"358": "B  96 ",
+"359": "B  97 ",
+"360": "B  98 ",
+"361": "B  99 ",
+"362": "B 100 ",
+"363": "B 101 ",
+"364": "B 102 ",
+"365": "B 103 ",
+"366": "B 104 ",
+"367": "B 105 ",
+"368": "B 106 ",
+"369": "B 107 ",
+"370": "B 108 ",
+"371": "B 109 ",
+"372": "B 110 ",
+"373": "B 111 ",
+"374": "B 112 ",
+"375": "B 113 ",
+"376": "B 114 ",
+"377": "B 115 ",
+"378": "B 116 ",
+"379": "B 117 ",
+"380": "B 118 ",
+"381": "B 119 ",
+"382": "B 120 ",
+"383": "B 121 ",
+"384": "B 122 ",
+"385": "B 123 ",
+"386": "B 124 ",
+"387": "B 125 ",
+"388": "B 126 ",
+"389": "B 127 ",
+"390": "B 128 ",
+"391": "B 129 ",
+"392": "B 130 ",
+"393": "B 131 ",
+"394": "B 132 ",
+"395": "B 133 ",
+"396": "B 134 ",
+"397": "B 135 ",
+"398": "B 136 ",
+"399": "B 137 ",
+"400": "B 138 ",
+"401": "B 139 ",
+"402": "B 140 ",
+"403": "B 141 ",
+"404": "B 142 ",
+"405": "B 143 ",
+"406": "B 144 ",
+"407": "B 145 ",
+"408": "B 146 ",
+"409": "B 147 ",
+"410": "B 148 ",
+"411": "B 149 ",
+"412": "B 150 ",
+"413": "B 151 ",
+"414": "B 152 ",
+"415": "B 153 ",
+"416": "B 154 ",
+"417": "B 155 ",
+"418": "B 156 ",
+"419": "B 157 ",
+"420": "B 158 ",
+"421": "B 159 ",
+"422": "B 160 ",
+"423": "B 161 ",
+"424": "B 162 ",
+"425": "B 163 ",
+"426": "B 164 ",
+"427": "B 165 "
+}

scripts/per_chain_protocol.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+Generate a copy of ddG-backrub.xml that additionally reports per-chain energies.
+
+Why
+---
+The `unbound_wt` / `unbound_mut` totals in ddG.db3 are whole-pose scores. InterfaceDdGMover
+builds the unbound state by rigid-body translating the moving chain(s) 1000 A apart, without
+repacking or re-minimizing, and every chain stays in the pose
+(protocols/features/InterfaceDdGMover.cc::unbind). So
+
+    unbound_X_total = sum over chains of intra(chain)        for X in {wt, mut}
+
+and `unbound_mut - unbound_wt` is the summed intramolecular ddG of *every* chain, including
+the ones that were never mutated. Those only differ between the wild type and mutant branches
+because the whole pose is re-minimized independently in each, so they contribute artifact.
+
+What this adds
+--------------
+A `TotalEnergyMetric` per chain, reported into ddG.db3 by the same ReportToDB mover that
+InterfaceDdGMover already applies to all four states. This is *reporting only* -- it adds no
+sampling, consumes no random numbers, and leaves ddG_bind bit-identical (verified against the
+unmodified protocol with -constant_seed).
+
+Reading the result
+------------------
+On the **unbound** states the chains are 1000 A apart, so there are no cross-chain pair
+energies and the reported value is exactly that chain's intramolecular energy. That is the
+number to use:
+
+    per-chain ddG(chain X) = intra_mut(X) - intra_wt(X)
+
+On the **bound** states the value is intra(chain) + roughly half the interface energy, because
+Rosetta's residue_total_energies splits each two-body term between its two residues. Those rows
+are useful as a cross-check (they sum to the pose total) but should not be read as per-chain
+stability numbers.
+
+Caveat this does NOT fix
+------------------------
+The unbound state is still never relaxed. This gives you the intramolecular strain difference
+*in the bound backbone conformation*, not a folding ddG of the free monomer. For that you want
+a dedicated monomer protocol (e.g. cartesian_ddg) run on the isolated chain.
+"""
+
+import os
+
+
+def chains_in_pdb(pdb_path):
+    """Chain IDs in the order they first appear in the PDB."""
+    chains = []
+    with open(pdb_path) as f:
+        for line in f:
+            if line.startswith(('ATOM', 'HETATM')):
+                chain = line[21]
+                if chain not in chains:
+                    chains.append(chain)
+    return chains
+
+
+def write_per_chain_protocol(base_xml_path, chains, out_path, scorefxn='fa_talaris2014'):
+    """Write a copy of base_xml_path with a per-chain TotalEnergyMetric for each chain.
+
+    Each chain gets its own database table (chain_<X>_energy) with a single `total_energy`
+    column. Separate tables rather than one table with prefixed columns is deliberate: as of
+    Rosetta 2022.45, SimpleMetricFeatures builds schema column names as `custom_type + name`
+    but builds the INSERT as `custom_type + "_" + name`, so any non-empty custom_type produces
+    "table simple_metrics has no column named ..." at report time.
+    """
+    if not chains:
+        raise ValueError('No chains given')
+
+    # Rosetta lowercases table names, so chains differing only in case would collide.
+    lowered = [c.lower() for c in chains]
+    if len(set(lowered)) != len(lowered):
+        raise ValueError('Chain IDs differ only by case, which collides in table names: %s' % chains)
+
+    xml = open(base_xml_path).read()
+
+    def substitute(text, anchor, addition):
+        if anchor not in text:
+            raise ValueError('Could not find anchor in %s:\n  %s' % (base_xml_path, anchor))
+        return text.replace(anchor, anchor + addition, 1)
+
+    selectors = ''.join(
+        '\n    <Chain name="chain_%s" chains="%s"/>' % (c, c) for c in chains)
+    xml = substitute(
+        xml, '    <StoredResidueSubset name="restore_neighbor_shell" subset_name="neighbor_shell"/>',
+        selectors)
+
+    metrics = '\n'.join(
+        '    <TotalEnergyMetric name="chain_%s_energy" residue_selector="chain_%s" scorefxn="%s"/>'
+        % (c, c, scorefxn) for c in chains)
+    anchor = '  <FILTERS>'
+    if anchor not in xml:
+        raise ValueError('Could not find FILTERS block in %s' % base_xml_path)
+    xml = xml.replace(anchor, '  <SIMPLE_METRICS>\n%s\n  </SIMPLE_METRICS>\n\n%s' % (metrics, anchor), 1)
+
+    reporters = ''.join(
+        '\n      <SimpleMetricFeatures metrics="chain_%s_energy" table_name="chain_%s_energy"/>'
+        % (c, c) for c in chains)
+    xml = substitute(
+        xml, '      <StructureScoresFeatures scorefxn="%s"/>' % scorefxn, reporters)
+
+    with open(out_path, 'w') as f:
+        f.write(xml)
+    return out_path
+
+
+if __name__ == '__main__':
+    import sys
+    if len(sys.argv) != 4:
+        sys.exit('usage: per_chain_protocol.py <base.xml> <input.pdb> <out.xml>')
+    base_xml, pdb, out = sys.argv[1:4]
+    found = chains_in_pdb(pdb)
+    write_per_chain_protocol(base_xml, found, out)
+    print('Wrote %s with per-chain metrics for chains: %s' % (out, ', '.join(found)))

scripts/reprocess_per_chain.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""
+Recover per-chain intramolecular energies from an EXISTING flex ddG run.
+
+No re-sampling is required. The backrub trajectory is the expensive part and you already ran
+it: struct.db3 holds the coordinates of every backrub, wild type minimized and mutant minimized
+pose. This script reads those poses back into Rosetta, isolates one chain at a time, rescores,
+and reports per-chain ddG. Verified to reproduce the in-protocol per-chain metric (see
+per_chain_protocol.py) to nine decimal places.
+
+Why the chains have to be physically isolated rather than just selected: struct.db3 stores the
+*bound* poses. A Chain residue selector scoped over a bound pose still picks up cross-chain pair
+energies, because Rosetta's residue_total_energies splits each two-body term between its two
+residues, so roughly half the interface energy leaks into each chain. Deleting the other chains
+reproduces the separated unbound state exactly, since intra-chain energy is invariant under the
+rigid-body translation InterfaceDdGMover uses to unbind.
+
+What this does and does not give you
+------------------------------------
+It gives you the intramolecular energy difference between the mutant and wild type in the
+*bound* backbone conformation, per chain. That is a strain term. It is NOT a folding ddG of the
+free monomer: the unbound state is never relaxed here, in this script or in flex ddG itself. For
+a true monomer stability ddG use a dedicated protocol such as cartesian_ddg on the isolated chain.
+
+Built-in control: a chain you did not mutate should come out at 0 within its SEM. If it does not,
+nstruct is too low to average out the whole-pose minimization noise, and the mutated chain's
+number is not trustworthy either.
+
+Usage
+-----
+    python3 reprocess_per_chain.py <output_folder> [--stride N] [--chains A,B] [--csv out.csv]
+
+The backrub_trajectory_stride is read back out of each struct.db3, so --stride is only needed
+for databases that do not record it. It affects the checkpoint labels, not any energy.
+"""
+
+import argparse
+import glob
+import os
+import re
+import sqlite3
+import subprocess
+import sys
+
+import numpy as np
+import pandas as pd
+
+import flex_ddg_db3
+
+rosetta_scripts_path = os.path.expanduser('~/rosetta/source/bin/rosetta_scripts')
+
+# Must match the score function the original run used.
+rosetta_flags = [
+    '-restore_talaris_behavior',
+    '-in:file:fullatom',
+    '-out:nooutput',
+]
+
+struct_db3_name = 'struct.db3'
+per_chain_db3_name = 'per_chain.db3'
+
+# flex ddG writes three poses per checkpoint, in this order.
+pose_order = ['backrub', 'wt', 'mut']
+
+
+def chains_in_struct_db3(struct_db3):
+    conn = sqlite3.connect(struct_db3)
+    try:
+        chains = [row[0] for row in conn.execute(
+            'SELECT DISTINCT chain_id FROM residue_pdb_identification ORDER BY chain_id')]
+    finally:
+        conn.close()
+    return [c for c in chains if c and c.strip()]
+
+
+def write_rescore_protocol(chains, out_path, scorefxn='fa_talaris2014'):
+    """Emit a RosettaScripts protocol that isolates and rescores each chain in turn."""
+    lowered = [c.lower() for c in chains]
+    if len(set(lowered)) != len(lowered):
+        raise ValueError('Chain IDs differ only by case, which collides in batch names: %s' % chains)
+
+    selectors = '\n'.join(
+        '    <Chain name="chain_%s" chains="%s"/>\n'
+        '    <Not name="not_chain_%s" selector="chain_%s"/>' % (c, c, c, c) for c in chains)
+
+    movers = '\n'.join(
+        '    <DeleteRegionMover name="isolate_chain_%s" residue_selector="not_chain_%s"/>\n'
+        '    <ReportToDB name="chain_%s_report" batch_description="per_chain" database_name="%s">\n'
+        '      <ScoreTypeFeatures/>\n'
+        '      <ScoreFunctionFeatures scorefxn="%s"/>\n'
+        '      <StructureScoresFeatures scorefxn="%s"/>\n'
+        '    </ReportToDB>' % (c, c, c, per_chain_db3_name, scorefxn, scorefxn) for c in chains)
+
+    steps = ['    <Add mover_name="save_full"/>']
+    for i, c in enumerate(chains):
+        if i > 0:
+            steps.append('    <Add mover_name="restore_full"/>')
+        steps.append('    <Add mover_name="isolate_chain_%s"/>' % c)
+        steps.append('    <Add mover_name="chain_%s_report"/>' % c)
+
+    xml = '''<ROSETTASCRIPTS>
+  <SCOREFXNS>
+    <ScoreFunction name="%s" weights="talaris2014"/>
+  </SCOREFXNS>
+
+  <RESIDUE_SELECTORS>
+%s
+  </RESIDUE_SELECTORS>
+
+  <MOVERS>
+    <SavePoseMover name="save_full" reference_name="full_pose" restore_pose="0"/>
+    <SavePoseMover name="restore_full" reference_name="full_pose" restore_pose="1"/>
+%s
+  </MOVERS>
+
+  <PROTOCOLS>
+%s
+  </PROTOCOLS>
+  <OUTPUT />
+</ROSETTASCRIPTS>
+''' % (scorefxn, selectors, movers, '\n'.join(steps))
+
+    with open(out_path, 'w') as f:
+        f.write(xml)
+    return out_path
+
+
+def rescore_one(struct_db3, protocol_path):
+    """Run the isolate-and-rescore protocol on one struct.db3, writing per_chain.db3 beside it."""
+    working_dir = os.path.dirname(os.path.abspath(struct_db3))
+    out_db3 = os.path.join(working_dir, per_chain_db3_name)
+    if os.path.isfile(out_db3):
+        os.remove(out_db3)
+
+    args = [
+        os.path.abspath(rosetta_scripts_path),
+        '-inout:dbms:database_name', struct_db3_name,
+        '-in:use_database',
+        '-parser:protocol', os.path.abspath(protocol_path),
+    ] + rosetta_flags
+
+    log_path = os.path.join(working_dir, 'per_chain_rescore.log')
+    with open(log_path, 'w') as log:
+        proc = subprocess.Popen(args, stdout=log, stderr=subprocess.STDOUT, cwd=working_dir)
+        returncode = proc.wait()
+
+    if returncode != 0 or not os.path.isfile(out_db3):
+        raise RuntimeError('Rescoring failed for %s -- see %s' % (struct_db3, log_path))
+    return out_db3
+
+
+def read_per_chain_db3(per_chain_db3, struct_number, case_name, stride):
+    conn = sqlite3.connect(per_chain_db3)
+    df = pd.read_sql_query('''
+    SELECT batches.name AS batch, structures.tag AS tag, structure_scores.score_value AS energy
+    FROM structure_scores
+    INNER JOIN structures ON structures.struct_id=structure_scores.struct_id
+    INNER JOIN batches ON batches.batch_id=structure_scores.batch_id
+    INNER JOIN score_types ON score_types.batch_id=structure_scores.batch_id
+                          AND score_types.score_type_id=structure_scores.score_type_id
+    WHERE score_types.score_type_name="total_score"
+    ''', conn)
+    conn.close()
+
+    # batch name is "chain_<X>_report"; tag is "<original struct.db3 struct_id>_0001"
+    df['chain'] = df['batch'].apply(lambda b: b[len('chain_'):-len('_report')])
+    original_id = df['tag'].apply(lambda t: int(re.match(r'(\d+)', t).group(1)))
+    df['pose'] = original_id.apply(lambda i: pose_order[(i - 1) % len(pose_order)])
+    df['backrub_steps'] = original_id.apply(lambda i: stride * (((i - 1) // len(pose_order)) + 1))
+    df['struct_num'] = struct_number
+    df['case_name'] = case_name
+    return df[['case_name', 'struct_num', 'backrub_steps', 'chain', 'pose', 'energy']]
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument('output_folder', help='flex ddG output folder (e.g. "output")')
+    parser.add_argument('--stride', type=int, default=None,
+                        help='override backrub_trajectory_stride instead of reading it from each '
+                             'struct.db3. Affects checkpoint labels only, not any energy.')
+    parser.add_argument('--chains', default=None,
+                        help='comma-separated chains (default: auto-detect from struct.db3)')
+    parser.add_argument('--csv', default=None, help='write the full per-structure table here')
+    parser.add_argument('--reuse', action='store_true',
+                        help='skip Rosetta where per_chain.db3 already exists')
+    args = parser.parse_args()
+
+    if not os.path.isfile(rosetta_scripts_path):
+        sys.exit('ERROR: set rosetta_scripts_path to your compiled rosetta_scripts binary')
+
+    struct_db3s = sorted(glob.glob(os.path.join(args.output_folder, '*', '*', struct_db3_name)))
+    if not struct_db3s:
+        sys.exit('ERROR: no %s found under %s' % (struct_db3_name, args.output_folder))
+    print('Found %d %s files' % (len(struct_db3s), struct_db3_name))
+
+    chains = args.chains.split(',') if args.chains else chains_in_struct_db3(struct_db3s[0])
+    print('Chains: %s' % ', '.join(chains))
+
+    protocol_path = os.path.join(args.output_folder, 'per_chain_rescore.generated.xml')
+    write_rescore_protocol(chains, protocol_path)
+    print('Wrote protocol %s\n' % protocol_path)
+
+    frames = []
+    for i, struct_db3 in enumerate(struct_db3s, start=1):
+        struct_dir = os.path.dirname(struct_db3)
+        case_name = os.path.basename(os.path.dirname(struct_dir))
+        struct_number = os.path.basename(struct_dir)
+        out_db3 = os.path.join(struct_dir, per_chain_db3_name)
+
+        if args.reuse and os.path.isfile(out_db3):
+            print('  [%d/%d] %s (reusing)' % (i, len(struct_db3s), struct_dir))
+        else:
+            print('  [%d/%d] %s' % (i, len(struct_db3s), struct_dir))
+            out_db3 = rescore_one(struct_db3, protocol_path)
+
+        stride = args.stride
+        if stride is None:
+            stride = flex_ddg_db3.trajectory_stride_from_db3(struct_db3)
+        if stride is None:
+            stride = 5
+            print('    WARNING: %s does not record backrub_trajectory_stride; assuming %d. '
+                  'Pass --stride to label the checkpoints correctly.' % (struct_db3, stride))
+
+        frames.append(read_per_chain_db3(out_db3, struct_number, case_name, stride))
+
+    per_structure = pd.concat(frames)
+    wide = per_structure[per_structure['pose'].isin(['wt', 'mut'])].pivot_table(
+        index=['case_name', 'chain', 'backrub_steps', 'struct_num'],
+        columns='pose', values='energy').reset_index()
+    wide['ddG'] = wide['mut'] - wide['wt']
+
+    if args.csv:
+        wide.to_csv(args.csv, index=False)
+        print('\nWrote %s' % args.csv)
+
+    summary = wide.groupby(['case_name', 'chain', 'backrub_steps']).agg(
+        nstruct=('ddG', 'size'),
+        wt_intra=('wt', 'mean'),
+        mut_intra=('mut', 'mean'),
+        ddG=('ddG', 'mean'),
+        ddG_sd=('ddG', 'std'),
+    ).reset_index()
+    summary['ddG_sem'] = summary['ddG_sd'] / np.sqrt(summary['nstruct'])
+
+    print('\n=== per-chain intramolecular ddG ===')
+    print(summary.round(4).to_string(index=False))
+    print('\nA chain you did NOT mutate should read ~0 within ddG_sem.')
+    print('This is bound-conformation strain, not a folding ddG (see the module docstring).')
+
+
+if __name__ == '__main__':
+    main()

scripts/run_example_1.py

@@ -0,0 +1,121 @@
+#!/usr/bin/python
+
+from __future__ import print_function
+
+import socket
+import sys
+import os
+import subprocess
+
+script_dir = os.path.dirname(os.path.abspath(__file__))
+project_root = os.path.dirname(script_dir)
+conf_dir = os.path.join(project_root, 'conf')
+inputs_dir = os.path.join(script_dir, 'inputs')
+
+use_multiprocessing = True
+if use_multiprocessing:
+    import multiprocessing
+    max_cpus = 2 # We might want to not run on the full number of cores, as Rosetta take about 2 Gb of memory per instance
+
+###################################################################################################################################################################
+# Important: The variables below are set to values that will make the run complete faster (as a tutorial example), but will not give scientifically valid results.
+#            Please change them to the "normal" default values before a real run.
+###################################################################################################################################################################
+
+#rosetta_scripts_path = os.path.expanduser("~/rosetta/source/bin/rosetta_scripts")
+rosetta_scripts_path = os.path.expanduser(
+"/public/home/scnb9biwet/jiangqq/flex_ddG_tutorial-master/software/rosetta3.9/main/source/bin/rosetta_scripts.default.linuxgccrelease"
+)
+nstruct = 3 # Normally 35
+max_minimization_iter = 5 # Normally 5000
+abs_score_convergence_thresh = 200.0 # Normally 1.0
+number_backrub_trials = 10 # Normally 35000
+backrub_trajectory_stride = 5 # Can be whatever you want, if you would like to see results from earlier time points in the backrub trajectory. 7000 is a reasonable number, to give you three checkpoints for a 35000 step run, but you could also set it to 35000 for quickest run time (as the final minimization and packing steps will only need to be run one time).
+path_to_script = os.path.join(conf_dir, 'ddG-backrub.xml')
+
+# Additionally report the intramolecular energy of each individual chain into ddG.db3.
+# This is reporting only: it adds no sampling, consumes no random numbers, and leaves the
+# binding ddG bit-identical. Read the per-chain numbers off the *unbound* states, where the
+# chains are 1000 A apart and the value is exactly that chain's intramolecular energy.
+# See per_chain_protocol.py for the full explanation and caveats.
+report_per_chain_energies = False
+
+if not os.path.isfile(rosetta_scripts_path):
+    print('ERROR: "rosetta_scripts_path" variable must be set to the location of the "rosetta_scripts" binary executable')
+    print('This file might look something like: "rosetta_scripts.linuxgccrelease"')
+    raise Exception('Rosetta scripts missing')
+
+def protocol_for( input_pdb_path ):
+    """Return the XML to run, generating the per-chain reporting variant if requested."""
+    if not report_per_chain_energies:
+        return os.path.abspath(path_to_script)
+
+    import per_chain_protocol
+    chains = per_chain_protocol.chains_in_pdb( input_pdb_path )
+    derived = os.path.abspath( os.path.splitext(path_to_script)[0] + '-per_chain.xml' )
+    per_chain_protocol.write_per_chain_protocol( path_to_script, chains, derived )
+    return derived
+
+def run_flex_ddg( name, input_path, input_pdb_path, chains_to_move, nstruct_i ):
+    output_directory = os.path.join( project_root, 'output', os.path.join( name, '%02d' % nstruct_i ) )
+    if not os.path.isdir(output_directory):
+        os.makedirs(output_directory)
+
+    flex_ddg_args = [
+        os.path.abspath(rosetta_scripts_path),
+        "-s %s" % os.path.abspath(input_pdb_path),
+        '-parser:protocol', protocol_for( input_pdb_path ),
+        '-parser:script_vars',
+        'chainstomove=' + chains_to_move,
+        'mutate_resfile_relpath=' + os.path.abspath( os.path.join( input_path, 'nataa_mutations.resfile' ) ),
+        'number_backrub_trials=%d' % number_backrub_trials,
+        'max_minimization_iter=%d' % max_minimization_iter,
+        'abs_score_convergence_thresh=%.1f' % abs_score_convergence_thresh,
+        'backrub_trajectory_stride=%d' % backrub_trajectory_stride ,
+        '-restore_talaris_behavior',
+        '-in:file:fullatom',
+        '-ignore_unrecognized_res',
+        '-ignore_zero_occupancy false',
+        '-ex1',
+        '-ex2',
+    ]
+
+    log_path = os.path.join(output_directory, 'rosetta.out')
+
+    print( 'Running Rosetta with args:' )
+    print( ' '.join(flex_ddg_args) )
+    print( 'Output logged to:', os.path.abspath(log_path) )
+    print()
+
+    outfile = open(log_path, 'w')
+    process = subprocess.Popen(flex_ddg_args, stdout=outfile, stderr=subprocess.STDOUT, close_fds = True, cwd = output_directory)
+    returncode = process.wait()
+    outfile.close()
+
+if __name__ == '__main__':
+    cases = []
+    for nstruct_i in range(1, nstruct + 1 ):
+        for case_name in os.listdir(inputs_dir):
+            case_path = os.path.join( inputs_dir, case_name )
+            for f in os.listdir(case_path):
+                if f.endswith('.pdb'):
+                    input_pdb_path = os.path.join( case_path, f )
+                    break
+
+            with open( os.path.join( case_path, 'chains_to_move.txt' ), 'r' ) as f:
+                chains_to_move = f.readlines()[0].strip()
+
+            cases.append( (case_name, case_path, input_pdb_path, chains_to_move, nstruct_i) )
+
+    if use_multiprocessing:
+        pool = multiprocessing.Pool( processes = min(max_cpus, multiprocessing.cpu_count()) )
+
+    for args in cases:
+        if use_multiprocessing:
+            pool.apply_async( run_flex_ddg, args = args )
+        else:
+            run_flex_ddg( *args )
+
+    if use_multiprocessing:
+        pool.close()
+        pool.join()

scripts/run_example_2_saturation.py

@@ -0,0 +1,116 @@
+#!/usr/bin/python
+
+from __future__ import print_function
+
+import socket
+import sys
+import os
+import subprocess
+
+script_dir = os.path.dirname(os.path.abspath(__file__))
+project_root = os.path.dirname(script_dir)
+conf_dir = os.path.join(project_root, 'conf')
+inputs_dir = os.path.join(script_dir, 'inputs')
+
+use_multiprocessing = True
+if use_multiprocessing:
+    import multiprocessing
+    max_cpus = 2 # We might want to not run on the full number of cores, as Rosetta take about 2 Gb of memory per instance
+
+###################################################################################################################################################################
+# Important: The variables below are set to values that will make the run complete faster (as a tutorial example), but will not give scientifically valid results.
+#            Please change them to the "normal" default values before a real run.
+###################################################################################################################################################################
+
+#rosetta_scripts_path = os.path.expanduser("~/rosetta/source/bin/rosetta_scripts")
+rosetta_scripts_path = os.path.expanduser(
+"/public/home/scnb9biwet/jiangqq/flex_ddG_tutorial-master/software/rosetta3.9/main/source/bin/rosetta_scripts.default.linuxgccrelease"
+)
+nstruct = 3 # Normally 35
+max_minimization_iter = 5 # Normally 5000
+abs_score_convergence_thresh = 200.0 # Normally 1.0
+number_backrub_trials = 10 # Normally 35000
+backrub_trajectory_stride = 5 # Can be whatever you want, if you would like to see results from earlier time points in the backrub trajectory. 7000 is a reasonable number, to give you three checkpoints for a 35000 step run, but you could also set it to 35000 for quickest run time (as the final minimization and packing steps will only need to be run one time).
+path_to_script = os.path.join(conf_dir, 'ddG-backrub.xml')
+residue_to_mutate = ('B', 49, '') # Residue position to perfrom saturation mutatagenesis. Format: (Chain, PDB residue number, insertion code).
+
+if not os.path.isfile(rosetta_scripts_path):
+    print('ERROR: "rosetta_scripts_path" variable must be set to the location of the "rosetta_scripts" binary executable')
+    print('This file might look something like: "rosetta_scripts.linuxgccrelease"')
+    raise Exception('Rosetta scripts missing')
+
+def run_flex_ddg_saturation( name, input_path, input_pdb_path, chains_to_move, mut_aa, nstruct_i ):
+    output_directory = os.path.join( project_root, 'output_saturation', os.path.join( '%s_%s' % (name, mut_aa), '%02d' % nstruct_i ) )
+    if not os.path.isdir(output_directory):
+        os.makedirs(output_directory)
+
+    mutation_chain, mutation_resi, mutation_icode = residue_to_mutate
+    resfile_path = os.path.join( output_directory, 'mutate_%s%d%s_to_%s.resfile' % (mutation_chain, mutation_resi, mutation_icode, mut_aa) )
+    with open( resfile_path, 'w') as f:
+        # Header must be NATAA, not NATRO. This resfile is used both to pick the mutated
+        # position and as the task operation for the mutant PackRotamersMover. With NATRO,
+        # the mutant branch freezes the 8 A neighbor shell while the wild type branch
+        # repacks it, which biases every ddG upwards by several REU (a self-mutation to the
+        # native amino acid comes out at +6 instead of 0).
+        f.write( 'NATAA\nstart\n%d%s %s PIKAA %s\n' % (mutation_resi, mutation_icode, mutation_chain, mut_aa) )
+
+    flex_ddg_args = [
+        os.path.abspath(rosetta_scripts_path),
+        "-s %s" % os.path.abspath(input_pdb_path),
+        '-parser:protocol', os.path.abspath(path_to_script),
+        '-parser:script_vars',
+        'chainstomove=' + chains_to_move,
+        'mutate_resfile_relpath=' + os.path.abspath( resfile_path ),
+        'number_backrub_trials=%d' % number_backrub_trials,
+        'max_minimization_iter=%d' % max_minimization_iter,
+        'abs_score_convergence_thresh=%.1f' % abs_score_convergence_thresh,
+        'backrub_trajectory_stride=%d' % backrub_trajectory_stride ,
+        '-restore_talaris_behavior',
+        '-in:file:fullatom',
+        '-ignore_unrecognized_res',
+        '-ignore_zero_occupancy false',
+        '-ex1',
+        '-ex2',
+    ]
+
+    log_path = os.path.join(output_directory, 'rosetta.out')
+
+    print( 'Running Rosetta with args:' )
+    print( ' '.join(flex_ddg_args) )
+    print( 'Output logged to:', os.path.abspath(log_path) )
+    print()
+
+    outfile = open(log_path, 'w')
+    process = subprocess.Popen(flex_ddg_args, stdout=outfile, stderr=subprocess.STDOUT, close_fds = True, cwd = output_directory)
+    returncode = process.wait()
+    outfile.close()
+
+if __name__ == '__main__':
+    mutation_chain, mutation_resi, mutation_icode = residue_to_mutate
+    cases = []
+    for nstruct_i in range(1, nstruct + 1 ):
+        for case_name in os.listdir(inputs_dir):
+            case_path = os.path.join( inputs_dir, case_name )
+            for f in os.listdir(case_path):
+                if f.endswith('.pdb'):
+                    input_pdb_path = os.path.join( case_path, f )
+                    break
+
+            with open( os.path.join( case_path, 'chains_to_move.txt' ), 'r' ) as f:
+                chains_to_move = f.readlines()[0].strip()
+
+            for mut_aa in 'ACDEFGHIKLMNPQRSTVWY':
+                cases.append( ('%s_%s%d%s' % (case_name, mutation_chain, mutation_resi, mutation_icode), case_path, input_pdb_path, chains_to_move, mut_aa, nstruct_i) )
+
+    if use_multiprocessing:
+        pool = multiprocessing.Pool( processes = min(max_cpus, multiprocessing.cpu_count()) )
+
+    for args in cases:
+        if use_multiprocessing:
+            pool.apply_async( run_flex_ddg_saturation, args = args )
+        else:
+            run_flex_ddg_saturation( *args )
+
+    if use_multiprocessing:
+        pool.close()
+        pool.join()