Update readme with the preprint

README.md

@@ -1,10 +1,12 @@
 # QligFEPv2 Benchmarking Experiments
 
-This repository contains the benchmarking experiments for **QligFEPv2**, an iteration on the development of the QligFEP software for relative binding free energy (RBFE) calculations. QligFEP is a Python-based tool that automates the setup, execution, and analysis of free energy perturbation (FEP) calculations using the [Q simulation package](https://github.com/qusers/Q6).
+This repository contains the benchmarking experiments for **QligFEPv2**, an iteration on the development of the QligFEP software for relative binding free energy (RBFE) calculations. QligFEP is a Python-based tool that automates the setup, execution, and analysis of free energy perturbation (FEP) calculations using the Q molecular dynamics engine.
 
-**Original QligFEP publication:** Jespers, W., Esguerra, M., Åqvist, J., Gutiérrez-de-Terán, H., QligFEP: an automated workflow for small molecule free energy calculations in Q. *J Cheminform* **11**, 26 (2019). https://doi.org/10.1186/s13321-019-0348-5
+## How-to
 
-> 📄 *Manuscript describing this work is coming soon.*
+To reproduce the benchmarking results, we recommend users to setup an enviroment following the instructions in the [qusers/Q repository](https://github.com/qusers/Q). Additional dependencies for analysis and visualization are listed below under [Interactive Dashboard](#interactive-dashboard).
+
+After setting up the environment and compiling Q, please check the section [Running FEP Calculations](#running-fep-calculations) for instructions on how to run the FEP calculations and analyze the results. This work relies on Slurm for job scheduling; see [Cluster configuration](#cluster-configuration) for adapting the scripts to your cluster.
 
 ## Overview
 
@@ -62,7 +64,9 @@ The dashboard provides:
 │       ├── <ligand>.prm    # Q parameter files
 │       ├── <ligand>.pdb    # Individual ligand structures
 │       ├── prepare.sh      # SLURM script to setup FEP calculations
-│       └── analyze.sh      # SLURM script to analyze results
+│       ├── analyze.sh      # SLURM script to analyze results
+│       ├── prepare-neq.sh  # SLURM script to setup non-equilibrium (NEQ²) FEP (JACS targets)
+│       └── analyze-neq.sh  # SLURM script to analyze NEQ² switching work (JACS targets)
 │
 ├── results/                # Analyzed FEP results
 │   └── <target>/
@@ -97,6 +101,14 @@ The `startFiles/` directory contains Jupyter notebooks documenting the complete
 
 ## Running FEP Calculations
 
+### Cluster configuration
+
+Every `setupFEP` command hardcodes `-c SNELLIUS`, which selects the profile we use for running jobs in the [Snellius HPC](https://servicedesk.surf.nl/wiki/spaces/WIKI/pages/30660184/Snellius). This setting includes parameters such as task count, walltime, module loads, and Q binary paths, coming from from QligFEP's [`settings.py`](https://github.com/qusers/Q/blob/main/src/QligFEP/settings/settings.py) (`CLUSTER_DICT`). To run on another cluster, add an entry for it there following the existing examples and pass `-c <YOUR_CLUSTER>` after adding the configuration to `settings.py` and to `CLUSTER_DICT`.
+
+If you need a specific partition to run on, you need to add a line in [QligFEP.py](https://github.com/qusers/Q/blob/main/src/QligFEP/qligfep.py#L922-L925), which writes the SLURM script, as we did for the HPC systems that required a custom partition.
+
+The scripts do not pin a Slurm partition. Our benchmark ran on Snellius' `rome` partition; if your cluster requires one, add an `#SBATCH -p <partition>` line to the scripts.
+
 ### Setup
 Navigate to a target directory and run the preparation script:
 ```bash
@@ -123,6 +135,30 @@ The `analyze.sh` script runs `qligfep_analyze` to:
 
 **Note:** Target-specific setup commands with restraint strategies are documented in [`perturbations/commands.md`](perturbations/commands.md).
 
+### Non-Equilibrium (NEQ²) FEP
+
+The eight JACS targets can also be run with the non-equilibrium **NEQ²** protocol as an alternative to the windowed equilibrium workflow. Instead of many fixed-λ windows, NEQ² drives λ continuously between the end states with the `qdyn_neq` engine and estimates ΔΔG from the forward/reverse switching work with BAR. Because each switching trajectory is independent, the runs are trivially parallelizable and are cost-matched to the equilibrium protocol (~510,000 steps/replicate).
+
+Each JACS target directory carries a `prepare-neq.sh` and `analyze-neq.sh` alongside the equilibrium scripts:
+```bash
+cd perturbations/<target>
+sbatch prepare-neq.sh   # setupFEP --neq: builds the NEQ switching inputs
+# ...submit the switching runs, then once they finish:
+cd 2.protein/ && submitFEPjobs && cd ../1.water/ && submitFEPjobs
+# submitFEPjobs needs to be added to your .bashrc; Check link for the function:
+# https://github.com/qusers/Q/tree/main/tutorials/Tyk2#job-submission
+#
+# After the jobs finish running, analyze the switching work:
+sbatch analyze-neq.sh   # calls qligfep_neq_analyze
+```
+
+NEQ² produces different result files than the equilibrium analyzer:
+- `<target>_neq_results.csv` - per-edge ΔΔG, forward/reverse work overlap, and switch counts
+- `<target>_neq_results_run_data.csv` - per-replicate run diagnostics
+- `<target>_neq_ddG_plot.png` - calculated vs. experimental ΔΔG plot
+
+The switching work is read from `neq_1_*.log` (forward) and `neq_0_*.log` (reverse) logs under each leg's `FEP_*/<T>/<replicate>/` directories, rather than the per-window energy files of the equilibrium runs. The full NEQ² protocol and per-target restraints are documented in [`perturbations/commands.md`](perturbations/commands.md#non-equilibrium-neq-fep). The method is described in the accompanying manuscript, *NEQ²: A Cost-Efficient Non-Equilibrium Approach for Alchemical Free-Energy Calculations in QligFEP*.
+
 ## Performance Results
 
 Comprehensive performance metrics and analysis are available in:
@@ -141,14 +177,27 @@ Comprehensive performance metrics and analysis are available in:
 
 ## Citation
 
-If you use this data or code, please cite:
+To cite QligFEPv2 and this benchmarking study, please use the following reference:
+```bibtex
+@article{araripe2026qligfepv2,
+  author  = {Alencar Araripe, David and Díaz-Holguín, Alejandro and Poso, Antti and van Westen, Gerard J. P. and Åqvist, Johan and Gutiérrez-de-Terán, Hugo and Jespers, Willem},
+  title   = {Doing More with Less: Accurate and Scalable Ligand Free Energy Calculations by Focusing on the Binding Site},
+  journal = {Journal of Chemical Information and Modeling},
+  year    = {2026},
+  volume  = {66},
+  number  = {6},
+  pages   = {3164--3172},
+  doi     = {10.1021/acs.jcim.5c02932},
+  url     = {https://doi.org/10.1021/acs.jcim.5c02932},
+}
+```
 
+If you use qligfep, also consider citing:
 - **QligFEP original paper**: Jespers, W., Esguerra, M., Åqvist, J., Gutiérrez-de-Terán, H., QligFEP: an automated workflow for small molecule free energy calculations in Q. *J Cheminform* **11**, 26 (2019). https://doi.org/10.1186/s13321-019-0348-5
 
+And if you use this benchmarking dataset, please cite:
 - **IndustryBenchmarks2024**: Baumann H., Alibay I., Horton J., Ries B., Henry M., *et al.*, OpenFreeEnergy/IndustryBenchmarks2024: v1.0.0 (v1.0.0). Zenodo. (2025) https://doi.org/10.5281/zenodo.17245550
 
-- **Manuscript for this work**: *Coming soon*
-
 ## License
 
 See [LICENSE](LICENSE) file for details.

perturbations/bace/analyze-neq.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+#
+#SBATCH --nodes=1
+#SBATCH --ntasks-per-node=1
+#SBATCH --mem-per-cpu=1024
+#              d-hh:mm:ss
+#SBATCH --time=0-1:00:00
+#SBATCH -J resneq-bace
+# BAR analysis of the NEQ2 switching work from prepare-neq.sh (see ../commands.md for the protocol).
+# No partition is set; add "#SBATCH -p <partition>" above if your cluster needs one.
+micromamba run -n qligfep_new qligfep_neq_analyze -p 2.protein -w 1.water -T 300 -u kcal -j mapping.json -exp ddg_value -t bace -o bace_neq_results.csv -log debug && mkdir -p results_bace_neq && mv bace_neq* results_bace_neq && cp mapping.json results_bace_neq

perturbations/bace/analyze.sh

@@ -5,6 +5,5 @@
 #SBATCH --mem-per-cpu=1024
 #              d-hh:mm:ss
 #SBATCH --time=0-1:00:00
-#SBATCH -p rome
 #SBATCH -J res-bace
 micromamba run -n qligfep_new qligfep_analyze -t bace -j mapping.json -log debug -exp ddg_value -m ddGbar -lamb 101 --save-verbose && mkdir -p results_bace && mv bace*  results_bace && cp mapping_ddG.json results_bace

perturbations/bace/prepare-neq.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+#
+#SBATCH --nodes=1
+#SBATCH --ntasks-per-node=2
+#SBATCH --mem-per-cpu=1024
+#              d-hh:mm:ss
+#SBATCH --time=0-24:00:00
+#SBATCH -J prepneq-bace
+# NEQ2 FEP setup, run in place of prepare.sh (see ../commands.md for the protocol).
+# No partition is set; add "#SBATCH -p <partition>" above if your cluster needs one.
+micromamba run -n qligfep_new python -c "from QligFEP.chemIO import MoleculeIO;molio = MoleculeIO('ligands.sdf');molio.write_sdf_separate('.')"
+micromamba run -n qligfep_new setupFEP -FF AMBER14sb -c SNELLIUS -r 25 -b auto --start 0.5 -R 10 -ts 2fs -clean dcd inp -j mapping.json -log info -rest hybridization_p -rs 42 -T 300 --neq --neq-reps 5 --neq-steps 50000 --neq-eq-steps 1000 --neq-relax-steps 5000 -L 8.0 --neq-schedule sigmoidal

perturbations/bace/prepare.sh

@@ -5,7 +5,6 @@
 #SBATCH --mem-per-cpu=1024
 #              d-hh:mm:ss
 #SBATCH --time=0-24:00:00
-#SBATCH -p rome
 #SBATCH -J prep-bace
-python -c "from QligFEP.chemIO import MoleculeIO;molio = MoleculeIO('ligands.sdf');molio.write_sdf_separate('.')"
+micromamba run -n qligfep_new python -c "from QligFEP.chemIO import MoleculeIO;molio = MoleculeIO('ligands.sdf');molio.write_sdf_separate('.')"
 micromamba run -n qligfep_new setupFEP -FF AMBER14sb -c SNELLIUS -r 25 -b auto --start 0.5 -R 10 -S sigmoidal -ts 2fs -clean dcd inp -j mapping.json -log info -rest hybridization_p -rs 42

perturbations/cdk2/analyze-neq.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+#
+#SBATCH --nodes=1
+#SBATCH --ntasks-per-node=1
+#SBATCH --mem-per-cpu=1024
+#              d-hh:mm:ss
+#SBATCH --time=0-1:00:00
+#SBATCH -J resneq-cdk2
+# BAR analysis of the NEQ2 switching work from prepare-neq.sh (see ../commands.md for the protocol).
+# No partition is set; add "#SBATCH -p <partition>" above if your cluster needs one.
+micromamba run -n qligfep_new qligfep_neq_analyze -p 2.protein -w 1.water -T 300 -u kcal -j mapping.json -exp ddg_value -t cdk2 -o cdk2_neq_results.csv -log debug && mkdir -p results_cdk2_neq && mv cdk2_neq* results_cdk2_neq && cp mapping.json results_cdk2_neq

perturbations/cdk2/analyze.sh

@@ -5,6 +5,5 @@
 #SBATCH --mem-per-cpu=1024
 #              d-hh:mm:ss
 #SBATCH --time=0-1:00:00
-#SBATCH -p rome
 #SBATCH -J res-cdk2
 micromamba run -n qligfep_new qligfep_analyze -t cdk2 -j mapping.json -log debug -exp ddg_value -m ddGbar -lamb 101 --save-verbose && mkdir -p results_cdk2 && mv cdk2*  results_cdk2 && cp mapping_ddG.json results_cdk2

perturbations/cdk2/prepare-neq.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+#
+#SBATCH --nodes=1
+#SBATCH --ntasks-per-node=2
+#SBATCH --mem-per-cpu=1024
+#              d-hh:mm:ss
+#SBATCH --time=0-24:00:00
+#SBATCH -J prepneq-cdk2
+# NEQ2 FEP setup, run in place of prepare.sh (see ../commands.md for the protocol).
+# No partition is set; add "#SBATCH -p <partition>" above if your cluster needs one.
+micromamba run -n qligfep_new python -c "from QligFEP.chemIO import MoleculeIO;molio = MoleculeIO('ligands.sdf');molio.write_sdf_separate('.')"
+micromamba run -n qligfep_new setupFEP -FF AMBER14sb -c SNELLIUS -r 25 -b auto --start 0.5 -R 10 -ts 2fs -clean dcd inp -j mapping.json -log info -rest heavyatom_p -rs 42 -wath 1.7 -T 300 --neq --neq-reps 5 --neq-steps 50000 --neq-eq-steps 1000 --neq-relax-steps 5000 -L 8.0 --neq-schedule sigmoidal

perturbations/cdk2/prepare.sh

@@ -5,7 +5,6 @@
 #SBATCH --mem-per-cpu=1024
 #              d-hh:mm:ss
 #SBATCH --time=0-24:00:00
-#SBATCH -p rome
 #SBATCH -J prep-cdk2
-python -c "from QligFEP.chemIO import MoleculeIO;molio = MoleculeIO('ligands.sdf');molio.write_sdf_separate('.')"
+micromamba run -n qligfep_new python -c "from QligFEP.chemIO import MoleculeIO;molio = MoleculeIO('ligands.sdf');molio.write_sdf_separate('.')"
 micromamba run -n qligfep_new setupFEP -FF AMBER14sb -c SNELLIUS -r 25 -b auto --start 0.5 -R 10 -S sigmoidal -ts 2fs -clean dcd inp -j mapping.json -log info -rest heavyatom_p -rs 42 -wath 1.7

perturbations/cdk8/analyze.sh

@@ -5,6 +5,5 @@
 #SBATCH --mem-per-cpu=1024
 #              d-hh:mm:ss
 #SBATCH --time=0-1:00:00
-#SBATCH -p rome
 #SBATCH -J res-cdk8
 micromamba run -n qligfep_new qligfep_analyze -t cdk8 -j mapping.json -log debug -exp ddg_value -m ddGbar -lamb 101 --save-verbose && mkdir -p results_cdk8 && mv cdk8*  results_cdk8 && cp mapping_ddG.json results_cdk8

perturbations/cdk8/prepare.sh

@@ -5,7 +5,6 @@
 #SBATCH --mem-per-cpu=1024
 #              d-hh:mm:ss
 #SBATCH --time=0-24:00:00
-#SBATCH -p rome
 #SBATCH -J prep-cdk8
-python -c "from QligFEP.chemIO import MoleculeIO;molio = MoleculeIO('ligands.sdf');molio.write_sdf_separate('.')"
+micromamba run -n qligfep_new python -c "from QligFEP.chemIO import MoleculeIO;molio = MoleculeIO('ligands.sdf');molio.write_sdf_separate('.')"
 micromamba run -n qligfep_new setupFEP -FF AMBER14sb -c SNELLIUS -r 25 -b auto --start 0.5 -R 10 -S sigmoidal -ts 2fs -clean dcd inp -j mapping.json -log info -rest hybridization_p -rs 42 -wath 1.9 -wath-ligo

perturbations/cmet/analyze.sh

@@ -5,6 +5,5 @@
 #SBATCH --mem-per-cpu=1024
 #              d-hh:mm:ss
 #SBATCH --time=0-1:00:00
-#SBATCH -p rome
 #SBATCH -J res-cmet
 micromamba run -n qligfep_new qligfep_analyze -t cmet -j mapping.json -log debug -exp ddg_value -m ddGbar -lamb 101 --save-verbose && mkdir -p results_cmet && mv cmet*  results_cmet && cp mapping_ddG.json results_cmet

perturbations/cmet/prepare.sh

@@ -5,7 +5,6 @@
 #SBATCH --mem-per-cpu=1024
 #              d-hh:mm:ss
 #SBATCH --time=0-24:00:00
-#SBATCH -p rome
 #SBATCH -J prep-cmet
-python -c "from QligFEP.chemIO import MoleculeIO;molio = MoleculeIO('ligands.sdf');molio.write_sdf_separate('.')"
+micromamba run -n qligfep_new python -c "from QligFEP.chemIO import MoleculeIO;molio = MoleculeIO('ligands.sdf');molio.write_sdf_separate('.')"
 micromamba run -n qligfep_new setupFEP -FF AMBER14sb -c SNELLIUS -r 25 -b auto --start 0.5 -R 10 -S sigmoidal -ts 2fs -clean dcd inp -j mapping.json -log info -rest heavyatom_ls -rs 42

perturbations/commands.md

@@ -18,6 +18,7 @@
     - [syk](#syk)
     - [pfkfb3](#pfkfb3)
     - [tnks2](#tnks2)
+- [Non-equilibrium (NEQ²) FEP](#non-equilibrium-neq-fep)
 
 # JACS dataset
 
@@ -219,4 +220,64 @@ setupFEP -FF AMBER14sb -c SNELLIUS -r 25 -b auto --start 0.5 -R 10 -S sigmoidal
 Analyze the results
 ```bash
 qligfep_analyze -t tnks2 -j mapping.json -log debug -exp ddg_value -m ddGbar -lamb 101 --save-verbose && mkdir -p results_tnks2 && mv tnks2*  results_tnks2 && cp mapping_ddG.json results_tnks2
-```
+```
+
+# Non-equilibrium (NEQ²) FEP
+
+The eight JACS targets (bace, cdk2, jnk1, mcl1, p38, ptp1b, thrombin, tyk2) can also be run with
+the non-equilibrium NEQ² workflow instead of the windowed equilibrium one. Each of those target
+directories carries a `prepare-neq.sh` and `analyze-neq.sh` next to the equilibrium
+`prepare.sh`/`analyze.sh`, submitted the same way (`sbatch prepare-neq.sh`, then
+`sbatch analyze-neq.sh` once the switching runs finish).
+
+NEQ² replaces the fixed-λ windows with continuous λ switching (`--neq`), driven by the `qdyn_neq`
+engine. The protocol values are the optimized defaults from the NEQ² manuscript and are held
+fixed across all targets; only the restraint method (`-rest`) and cdk2's `-wath` differ per
+target, exactly as in the equilibrium commands above.
+
+Setup (shown for tyk2; swap `-rest`/target name as in the equilibrium table):
+```bash
+setupFEP -FF AMBER14sb -c SNELLIUS -r 25 -b auto --start 0.5 -R 10 -ts 2fs -clean dcd inp -j mapping.json -log info -rest hybridization_p -rs 42 -T 300 --neq --neq-reps 5 --neq-steps 50000 --neq-eq-steps 1000 --neq-relax-steps 5000 -L 8.0 --neq-schedule sigmoidal
+```
+
+Analyze:
+```bash
+qligfep_neq_analyze -p 2.protein -w 1.water -T 300 -u kcal -j mapping.json -exp ddg_value -t tyk2 -o tyk2_neq_results.csv -log debug
+```
+
+Protocol parameters (cost-matched to the equilibrium 510,000 steps/replicate = 5 × (2×1000 + 2×50000)):
+
+| Flag | Meaning | Value |
+|------|---------|-------|
+| `--neq-schedule` | λ switching schedule | sigmoidal |
+| `-L` | schedule steepness | 8.0 |
+| `--neq-steps` | tNEQ, switch length | 50000 (100 ps @ 2 fs) |
+| `--neq-eq-steps` | tEQ, equilibration between switches | 1000 steps |
+| `--neq-relax-steps` | one-time endpoint relaxation at λ=0 and λ=1 | 5000 (10 ps @ 2 fs) |
+| `--neq-reps` | N, forward/reverse switch pairs per replicate | 5 |
+| `-R` | independent replicates | 10 |
+| `-T` | production temperature | 300 K |
+
+Two settings matter beyond the CLI defaults: `-T 300` (both `setupFEP` and `qligfep_neq_analyze`
+default to 298) and, for the analyzer, `-u kcal` (the BAR work units).
+
+Per-target restraint (identical to the equilibrium runs above):
+
+| Target | `-rest` | extra |
+|--------|---------|-------|
+| bace | hybridization_p | |
+| cdk2 | heavyatom_p | -wath 1.7 |
+| jnk1 | hybridization_p | |
+| mcl1 | heavyatom_p | |
+| p38 | heavyatom_p | |
+| ptp1b | heavyatom_p | |
+| thrombin | hybridization_p | |
+| tyk2 | hybridization_p | |
+
+NEQ² writes different output files than the equilibrium analyzer: `<target>_neq_results.csv`
+(per-edge ΔΔG, forward/reverse work overlap, and forward/reverse/failed switch counts),
+`<target>_neq_results_run_data.csv` (per-replicate run diagnostics), and `<target>_neq_ddG_plot.png`
+— in place of the parquet/JSON files. The switching work itself is read from `neq_1_*.log`
+(forward, λ 1→0) and `neq_0_*.log` (reverse, λ 0→1) under each `<leg>/FEP_*/<T>/<replicate>/`
+directory. `-clean dcd inp` removes the heavy trajectory and input files after each run; the
+`neq_*.log` work files that BAR needs are kept.

perturbations/eg5/analyze.sh

@@ -5,6 +5,5 @@
 #SBATCH --mem-per-cpu=1024
 #              d-hh:mm:ss
 #SBATCH --time=0-1:00:00
-#SBATCH -p rome
 #SBATCH -J res-eg5
 micromamba run -n qligfep_new qligfep_analyze -t eg5 -j mapping.json -log debug -exp ddg_value -m ddGbar -lamb 101 --save-verbose && mkdir -p results_eg5 && mv eg5*  results_eg5 && cp mapping_ddG.json results_eg5

perturbations/eg5/prepare.sh

@@ -5,7 +5,6 @@
 #SBATCH --mem-per-cpu=1024
 #              d-hh:mm:ss
 #SBATCH --time=0-24:00:00
-#SBATCH -p rome
 #SBATCH -J prep-eg5
-python -c "from QligFEP.chemIO import MoleculeIO;molio = MoleculeIO('ligands.sdf');molio.write_sdf_separate('.')"
+micromamba run -n qligfep_new python -c "from QligFEP.chemIO import MoleculeIO;molio = MoleculeIO('ligands.sdf');molio.write_sdf_separate('.')"
 micromamba run -n qligfep_new setupFEP -FF AMBER14sb -c SNELLIUS -r 25 -b auto --start 0.5 -R 10 -S sigmoidal -ts 2fs -clean dcd inp -j mapping.json -log info -rest heavyatom_p -rs 42

perturbations/hif2a/analyze.sh

@@ -5,6 +5,5 @@
 #SBATCH --mem-per-cpu=1024
 #              d-hh:mm:ss
 #SBATCH --time=0-1:00:00
-#SBATCH -p rome
 #SBATCH -J res-hif2a
 micromamba run -n qligfep_new qligfep_analyze -t hif2a -j mapping.json -log debug -exp ddg_value -m ddGbar -lamb 101 --save-verbose && mkdir -p results_hif2a && mv hif2a*  results_hif2a && cp mapping_ddG.json results_hif2a

perturbations/hif2a/prepare.sh

@@ -5,7 +5,6 @@
 #SBATCH --mem-per-cpu=1024
 #              d-hh:mm:ss
 #SBATCH --time=0-24:00:00
-#SBATCH -p rome
 #SBATCH -J prep-hif2a
-python -c "from QligFEP.chemIO import MoleculeIO;molio = MoleculeIO('ligands.sdf');molio.write_sdf_separate('.')"
+micromamba run -n qligfep_new python -c "from QligFEP.chemIO import MoleculeIO;molio = MoleculeIO('ligands.sdf');molio.write_sdf_separate('.')"
 micromamba run -n qligfep_new setupFEP -FF AMBER14sb -c SNELLIUS -r 25 -b auto --start 0.5 -R 10 -S sigmoidal -ts 2fs -clean dcd inp -j mapping.json -log info -rest heavyatom_p -rs 42

perturbations/jnk1/analyze-neq.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+#
+#SBATCH --nodes=1
+#SBATCH --ntasks-per-node=1
+#SBATCH --mem-per-cpu=1024
+#              d-hh:mm:ss
+#SBATCH --time=0-1:00:00
+#SBATCH -J resneq-jnk1
+# BAR analysis of the NEQ2 switching work from prepare-neq.sh (see ../commands.md for the protocol).
+# No partition is set; add "#SBATCH -p <partition>" above if your cluster needs one.
+micromamba run -n qligfep_new qligfep_neq_analyze -p 2.protein -w 1.water -T 300 -u kcal -j mapping.json -exp ddg_value -t jnk1 -o jnk1_neq_results.csv -log debug && mkdir -p results_jnk1_neq && mv jnk1_neq* results_jnk1_neq && cp mapping.json results_jnk1_neq