From a49759094b6588a98dab1faca15ea5fd173ab407 Mon Sep 17 00:00:00 2001
From: Robert Schoefbeck <robert.schoefbeck@cern.ch>
Date: Sun, 29 Mar 2026 12:21:58 +0200
Subject: [PATCH 01/17] claude-rs-devel

---
 ML/BIT/CLAUDE.md | 200 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 200 insertions(+)
 create mode 100644 ML/BIT/CLAUDE.md

diff --git a/ML/BIT/CLAUDE.md b/ML/BIT/CLAUDE.md
new file mode 100644
index 0000000..20f0b3a
--- /dev/null
+++ b/ML/BIT/CLAUDE.md
@@ -0,0 +1,200 @@
+# BIT Optimization Project
+
+## Goal
+Optimize the Boosted Information Tree (BIT) algorithm for:
+1. **Training time** (primary)
+2. **Evaluation/inference time** (primary)
+3. **Memory consumption** (important, spikes are damaging)
+4. **I/O / data loading** (secondary, optimize if it shows up as bottleneck)
+
+## Files to Optimize
+All in `/users/robert.schoefbeck/claude/GOLLUM/ML/BIT/`:
+- `NumbaMultiNode.py` — core tree node logic, split finding, Numba kernels
+- `NumbaBIT.py` — boosted tree training loop
+- `pdf_bit_training.py` — training script / entry point
+- `../../data/RDataLoader.py` — data loader (optimize only if I/O is a bottleneck)
+
+## Working Directory
+Always run benchmarks from:
+```
+/users/robert.schoefbeck/claude/GOLLUM/ML/BIT
+```
+
+## Benchmark Command
+```bash
+memray run --output benchmark.bin pdf_bit_training.py \
+  ../../configs/benchmark/unbinned_delphes_6_RunII.yaml \
+  --every 1 \
+  --job bit_NG_PDF4LHC21_6_tt2l_delphes \
+  --overwrite \
+  --max_n_files 1 \
+  --profile \
+  --postfix <current_iteration_label>
+```
+
+Followed immediately by:
+```bash
+memray stats benchmark.bin
+```
+
+## Mandatory Flags (always include these)
+| Flag | Reason |
+|------|--------|
+| `--every 1` | Required for meaningful results |
+| `--profile` | Enables CPU profiling output to stdout |
+| `--job bit_NG_PDF4LHC21_6_tt2l_delphes` | Selects the benchmark job |
+| `--overwrite` | Overwrites earlier results so comparisons are clean |
+
+## Variable Flags
+- `--max_n_files 1` — default; use a small number for quick iterations. Increase (e.g. to 3 or 5) if a heavier test is needed to confirm a result is not noise.
+- `--postfix <label>` — change this each iteration (e.g. `baseline`, `iter-01-numba-prange`, `iter-02-vectorized-predict`) so plot directories are traceable.
+
+## Profiling Output
+- **CPU profile** prints directly to stdout during the run — read it carefully
+- **Memory profile** is captured by memray; always run `memray stats benchmark.bin` after each run
+- Pay special attention to **memory spikes** (peak >> current at end of run), not just peak usage
+
+## Optimization Log
+Keep a running log here after each iteration.
+
+### Baseline
+- postfix: `first-try`
+- What was changed: nothing, baseline measurement
+- CPU hotspots: 
+================= cProfile (sorted by tottime) =================                                                                                                                                               
+         1070 function calls in 10.007 seconds                                                                                                                                                                 
+                                                                                                                                                                                                               
+   Ordered by: internal time                                                                                                                                                                                   
+   List reduced from 123 to 60 due to restriction <60>                                                                                                                                                         
+                                                                                                                                                                                                               
+   ncalls  tottime  percall  cumtime  percall filename:lineno(function)                                                                                                                                        
+        1    9.707    9.707    9.707    9.707 NumbaMultiNode.py:47(_mse_neg_loss_gains)                                                                                                                        
+        1    0.123    0.123    9.919    9.919 NumbaMultiNode.py:312(get_split_vectorized)                                                                                                                      
+        2    0.043    0.021    0.043    0.021 {built-in method numpy.array}                                                                                                                                    
+        8    0.040    0.005    0.040    0.005 {method 'astype' of 'numpy.ndarray' objects}                                                                                                                     
+        1    0.039    0.039    0.039    0.039 {method 'reduceat' of 'numpy.ufunc' objects}                                                                                                                     
+        1    0.017    0.017    0.017    0.017 {method 'argsort' of 'numpy.ndarray' objects}                                                                                                                    
+        1    0.014    0.014    0.014    0.014 {method 'searchsorted' of 'numpy.ndarray' objects}                                                                                                               
+        1    0.013    0.013    0.013    0.013 {method 'partition' of 'numpy.ndarray' objects}                                                                                                                  
+        1    0.005    0.005   10.008   10.008 NumbaMultiNode.py:119(__init__)                                                                                                                                  
+       10    0.004    0.000    0.004    0.000 {method 'reduce' of 'numpy.ufunc' objects}                                                                                                                       
+        3    0.001    0.000    0.001    0.000 {method 'flatten' of 'numpy.ndarray' objects}                                                                                                                    
+        1    0.000    0.000    0.000    0.000 _linalg.py:1639(svd)                                                                                                                                             
+      756    0.000    0.000    0.000    0.000 {built-in method _functools.reduce}                                                                                                                              
+        1    0.000    0.000    0.014    0.014 _function_base_impl.py:4771(_quantile)                                                                                                                           
+        1    0.000    0.000    0.000    0.000 {method 'nonzero' of 'numpy.ndarray' objects}                                                                                                                    
+        1    0.000    0.000    0.000    0.000 _linalg.py:2010(matrix_rank)                                                                                                                                     
+        2    0.000    0.000    0.000    0.000 _arraysetops_impl.py:339(_unique1d)                                                                                                                              
+        2    0.000    0.000    0.000    0.000 {method 'cumsum' of 'numpy.ndarray' objects}                                                                                                                     
+        1    0.000    0.000    0.000    0.000 function_base.py:25(linspace)                                                                                                                                    
+        1    0.000    0.000    0.000    0.000 _function_base_impl.py:4736(_get_indexes)                                                                                                                        
+        1    0.000    0.000    0.000    0.000 _function_base_impl.py:4639(_lerp)                                                                                                                               
+        5    0.000    0.000    0.031    0.006 fromnumeric.py:51(_wrapfunc)                                                                                                                                     
+        2    0.000    0.000    0.000    0.000 {built-in method numpy.zeros}                                                                                                                                    
+        1    0.000    0.000    0.000    0.000 {built-in method builtins.sum}                                                                                                                                   
+        2    0.000    0.000    0.000    0.000 {method 'sort' of 'numpy.ndarray' objects}                                                                                                                       
+        2    0.000    0.000    0.000    0.000 _arraysetops_impl.py:145(unique)                                                                                                                                 
+        1    0.000    0.000    0.000    0.000 numeric.py:137(ones)                                                                                                                                             
+        1    0.000    0.000    0.000    0.000 fromnumeric.py:89(_wrapreduction_any_all)                                                                                                                        
+        2    0.000    0.000    0.004    0.002 fromnumeric.py:69(_wrapreduction)                                                                                                                                
+        1    0.000    0.000    0.015    0.015 _function_base_impl.py:3834(_ureduce)                                                                                                                            
+        1    0.000    0.000    0.000    0.000 NumbaMultiNode.py:142(<dictcomp>)                                                                                                                                
+        1    0.000    0.000    0.001    0.001 NumbaMultiNode.py:149(<listcomp>)                                                                                                                                
+        1    0.000    0.000    0.000    0.000 _function_base_impl.py:107(<lambda>)                                                                                                                             
+        4    0.000    0.000    0.000    0.000 numerictypes.py:471(issubdtype)                                                                                                                                  
+        1    0.000    0.000    0.015    0.015 _function_base_impl.py:4697(_quantile_ureduce_func)                                                                                                              
+        1    0.000    0.000    0.000    0.000 fromnumeric.py:1904(ravel)                                                                                                                                       
+        1    0.000    0.000    0.000    0.000 numeric.py:450(count_nonzero)                                                                                                                                    
+        1    0.000    0.000    0.000    0.000 numeric.py:646(flatnonzero)                                                                                                                                      
+        1    0.000    0.000    0.015    0.015 _function_base_impl.py:4283(quantile)                                                                                                                            
+        1    0.000    0.000    0.000    0.000 _function_base_impl.py:4615(_get_gamma)                                                                                                                          
+        1    0.000    0.000    0.000    0.000 _ufunc_config.py:440(__enter__)                                                                                                                                  
+       31    0.000    0.000    0.000    0.000 {built-in method builtins.sorted}                                                                                                                                
+        8    0.000    0.000    0.000    0.000 numerictypes.py:289(issubclass_)                                                                                                                                 
+        1    0.000    0.000    0.000    0.000 _linalg.py:148(_commonType)                                                                                                                                      
+        1    0.000    0.000    0.000    0.000 getlimits.py:493(__new__)                                                                                                                                        
+       15    0.000    0.000    0.000    0.000 {built-in method builtins.issubclass}                                                                                                                            
+        3    0.000    0.000    0.000    0.000 multiarray.py:180(concatenate)                                                                                                                                   
+        1    0.000    0.000    9.919    9.919 NumbaMultiNode.py:583(split)                                                                                                                                     
+        2    0.000    0.000    0.000    0.000 fromnumeric.py:2879(cumsum)                                                                                                                                      
+        1    0.000    0.000    0.000    0.000 NumbaMultiNode.py:168(<listcomp>)                                                                                                                                
+        1    0.000    0.000    0.002    0.002 fromnumeric.py:3190(min)                                                                                                                                         
+        3    0.000    0.000    0.000    0.000 {built-in method numpy.empty}                                                                                                                                    
+        1    0.000    0.000    0.015    0.015 _function_base_impl.py:4541(_quantile_unchecked)                                                                                                                 
+        5    0.000    0.000    0.000    0.000 {method 'get' of 'dict' objects}                                                                                                                                 
+        1    0.000    0.000    0.000    0.000 _ufunc_config.py:430(__init__)                                                                                                                                   
+        1    0.000    0.000    0.000    0.000 _function_base_impl.py:4561(_quantile_is_valid)                                                                                                                  
+       10    0.000    0.000    0.000    0.000 {built-in method builtins.getattr}                                                                                                                               
+        1    0.000    0.000    0.000    0.000 {built-in method numpy.arange}                                                                                                                                   
+       15    0.000    0.000    0.000    0.000 {built-in method builtins.setattr}                                                                                                                               
+       39    0.000    0.000    0.000    0.000 {built-in method builtins.len}           
+
+- Memory current / peak: (fill in after first run)
+{ clip-login-0:~/claude/GOLLUM/ML/BIT }$ memray stats benchmark.bin
+📏 Total allocations:
+    17321848
+
+📦 Total memory allocated:
+    217.067GB
+
+📊 Histogram of allocation size:
+    min: 1.000B
+    ----------------------------------------------
+    < 6.000B   :  101813 ▇
+    < 43.000B  :  817168 ▇▇▇
+    < 282.000B : 8000678 ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇
+    < 1.808KB  : 7803531 ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇
+    < 11.858KB :  242286 ▇
+    < 77.790KB :   58730 ▇
+    < 510.266KB:  108477 ▇
+    < 3.269MB  :  186866 ▇
+    < 21.441MB :    1229 ▇
+    <=140.640MB:    1070 ▇
+    ----------------------------------------------
+    max: 140.640MB
+
+📂 Allocator type distribution:
+     MALLOC: 17136975
+     POSIX_MEMALIGN: 95337
+     REALLOC: 70508
+     CALLOC: 17274
+     MMAP: 1754
+
+🥇 Top 5 largest allocating locations (by size):
+    - <stack trace unavailable> -> 165.051GB
+    - get_split_vectorized:/users/robert.schoefbeck/claude/GOLLUM/ML/BIT/../../ML/BIT/NumbaMultiNode.py:378 -> 30.291GB
+    - <listcomp>:/users/robert.schoefbeck/claude/GOLLUM/pdf/PODBasis.py:296 -> 4.912GB
+    - _wrapfunc:/groups/hephy/cms/robert.schoefbeck/conda/envs/hephy-ml-gpu-claude/lib/python3.10/site-packages/numpy/_core/fromnumeric.py:57 -> 4.607GB
+    - get_data:<frozen importlib._bootstrap_external>:1073 -> 1.403GB
+
+🥇 Top 5 largest allocating locations (by number of allocations):
+    - <listcomp>:/users/robert.schoefbeck/claude/GOLLUM/pdf/PODBasis.py:296 -> 12291012
+    - evaluate:/users/robert.schoefbeck/claude/GOLLUM/pdf/PODBasis.py:294 -> 2048968
+    - <stack trace unavailable> -> 1877441
+    - <listcomp>:/users/robert.schoefbeck/claude/GOLLUM/pdf/PODBasis.py:243 -> 129469
+    - __init__:/groups/hephy/cms/robert.schoefbeck/conda/envs/hephy-ml-gpu-claude/lib/python3.10/ctypes/__init__.py:374 -> 121684
+
+- Notes:
+
+### Iteration 01
+- postfix: `iter-01-...`
+- What was changed:
+- CPU hotspots before/after:
+- Memory before/after:
+- Verdict: improvement / no change / regression
+
+*(add iterations here)*
+
+## Ground Rules
+- Always explain what you are about to do and why before making changes
+- Never change algorithmic correctness — only optimize numerics and data throughput
+- After each change, run the full benchmark and compare to the previous iteration
+- If a change is a regression, revert it and note why
+- Commit working improvements to git with a descriptive message before moving to the next iteration
+- If unsure whether a heavier test is needed, increase `--max_n_files` to 3 before concluding
+
+## Known Optimization Targets (starting hypotheses)
+- `vectorized_predict` uses `eval()` on dynamically constructed strings — replace with proper numpy tree traversal
+- Feature loop in `get_split_vectorized` is sequential — `numba.prange` could parallelize across features
+- `np.cumsum` in exact mode allocates full `(N, D)` copy of `training_weights` — potential spike source
+- Memory layout of `training_weights`: accessed row-wise in cumsum but column-wise in Numba kernels — transposing upfront may help cache performance

From 714872e134e62394dad56f3ae51616e0e1c480af Mon Sep 17 00:00:00 2001
From: Robert Schoefbeck <robert.schoefbeck@cern.ch>
Date: Sat, 11 Apr 2026 12:49:38 +0200
Subject: [PATCH 02/17] delphes

---
 ML/PNN/pnn_training_closure.py                |  20 +-
 .../benchmark/unbinned_delphes_6_RunII.yaml   |   2 +-
 data/samples_RunII.py                         |   3 +-
 orth/orthogonalize_Fisher.py                  |   2 +-
 plot/bit/bit_plot.py                          | 371 +++++++++++++++++-
 plot/bit/propaganda_plot_options.py           |   4 +-
 6 files changed, 372 insertions(+), 30 deletions(-)

diff --git a/ML/PNN/pnn_training_closure.py b/ML/PNN/pnn_training_closure.py
index ad73824..a0ef432 100644
--- a/ML/PNN/pnn_training_closure.py
+++ b/ML/PNN/pnn_training_closure.py
@@ -19,13 +19,16 @@
 from tqdm import tqdm
 
 # Plot options (binning, labels, optional y_ratio_range)
-from data.plot_options import plot_options as PLOT_OPTS
+
+#from data.plot_options import plot_options as PLOT_OPTS
+from plot.bit.propaganda_plot_options import plot_options as PLOT_OPTS #temporary change
 
 # ---------------- args ----------------
 p = argparse.ArgumentParser(description="PNN training-closure per-feature plots (YAML-driven)")
 p.add_argument("config", help="Path to global YAML config")
 p.add_argument("--job", default=None, help="PNN job id to run (omit to list)")
 p.add_argument("--small", action="store_true", help="Only first shard for debugging")
+p.add_argument("--lumi_scale", type=float, default=None, help="Scale lumi?")
 p.add_argument("--for_debug", action="store_true", help="Use _for_debug directories")
 p.add_argument("--n_split", default=None, help="Set sample split")
 args = p.parse_args()
@@ -160,12 +163,17 @@ def list_and_exit():
 
     loaders.append(eff_loader)
 
-# Reset n_split
-if args.n_split:
-    for l in loaders:
-        if isinstance(l, SelectionView):
+for l in loaders:
+    # Reset n_split
+    if isinstance(l, SelectionView):
+        if args.lumi_scale is not None:
+            l.base.weight_rescale = args.lumi_scale 
+        if args.n_split:
             l.base.split = args.n_split
-        else:
+    else:
+        if args.lumi_scale is not None:
+            l.weight_rescale = args.lumi_scale 
+        if args.n_split:
             l.split = args.n_split
 
 # ---------------- sanity: same features across loaders ----------------
diff --git a/configs/benchmark/unbinned_delphes_6_RunII.yaml b/configs/benchmark/unbinned_delphes_6_RunII.yaml
index 7e83f7f..74b6b48 100644
--- a/configs/benchmark/unbinned_delphes_6_RunII.yaml
+++ b/configs/benchmark/unbinned_delphes_6_RunII.yaml
@@ -56,7 +56,7 @@ jobs:
       pdf_type: PODBasis
       pdf_basis: gluon_POD_nongluon_PDF4LHC21 
     model:
-      n_trees: 20
+      n_trees: 10
       learning_rate: 0.2
       loss: MSE                   # or "CrossEntropy"
       learn_global_score: true
diff --git a/data/samples_RunII.py b/data/samples_RunII.py
index e38655d..c7cb31d 100644
--- a/data/samples_RunII.py
+++ b/data/samples_RunII.py
@@ -91,7 +91,8 @@ def _get_base() -> RDataLoader:
 delphes_OBSERVERS = ["Generator_x1", "Generator_x2", "Generator_id1", "Generator_id2", "Generator_scalePDF", "tr_isvalid", "run", "luminosityBlock", "event"]
 tt2l_delphes = RDataLoader( 
         input_paths=[ 
-            "/scratch/rschoefbeck/TTLep_pow_selected/",
+            #"/scratch/rschoefbeck/TTLep_pow_selected/",
+            "/scratch-cbe/users/robert.schoefbeck/TT2lUnbinned/nanoTuples/delphes/v1/TTLep_pow_selected/",
             #"/scratch-cbe/users/robert.schoefbeck/TT2lUnbinned/nanoTuples/delphes/v1/TTLep_pow_selected/TTLep_pow_0.root",
             #"/scratch-cbe/users/robert.schoefbeck/TT2lUnbinned/nanoTuples/delphes/v1/TTLep_pow_selected/TTLep_pow_1.root",
             #"/scratch-cbe/users/robert.schoefbeck/TT2lUnbinned/nanoTuples/delphes/v1/TTLep_pow_selected/TTLep_pow_2.root",
diff --git a/orth/orthogonalize_Fisher.py b/orth/orthogonalize_Fisher.py
index 472c277..49901c6 100644
--- a/orth/orthogonalize_Fisher.py
+++ b/orth/orthogonalize_Fisher.py
@@ -305,7 +305,7 @@
 ymin = 0.5 * np.min(lam_pos)
 ymax = 2.0 * np.max(lam_pos)
 log_span = np.log10(ymax / ymin)
-half_bar_decades = 0.025 * log_span
+half_bar_decades = 0.01 * log_span
 
 def yband(yv):
     return yv / (10.0 ** half_bar_decades), yv * (10.0 ** half_bar_decades)
diff --git a/plot/bit/bit_plot.py b/plot/bit/bit_plot.py
index 9d6b532..0a8bedc 100644
--- a/plot/bit/bit_plot.py
+++ b/plot/bit/bit_plot.py
@@ -25,6 +25,14 @@
 from propaganda_plot_options import plot_options as PLOT_OPTS
 import common.syncer as syncer
 import common.helpers as helpers
+
+from fit.Likelihood import (
+    load_likelihood,
+    build_hypothesis_from_likelihood,
+    _predict_classifier,
+    predict_pnn_deltaA,
+)
+
 # --------------------------------------------------------------------------------
 # hard-coded knobs
 # --------------------------------------------------------------------------------
@@ -35,7 +43,13 @@
 SHOW_ONLY = [("c0",), ("c1",), ("c2",), ("c3",), ("c4",), ("c5",)]
 
 # --small will stop after this many selected events
-SMALL_MAX_EVENTS = 20000
+SMALL_MAX_EVENTS = 500000
+
+# nuisance toy sampling
+NUISANCE_N_TOYS = 1000
+NUISANCE_TOY_RNG_SEED = 42
+NUISANCE_TOY_MEAN = 0.0
+NUISANCE_TOY_SIGMA = 1.0
 
 # More discernible hard-coded colors (Wong/Okabe-Ito style + a few extras)
 COLOR_HEX = [
@@ -91,6 +105,7 @@ def map_right_to_left(values, right_min, right_max, left_max):
 p.add_argument("config", help="Path to global YAML config")
 p.add_argument("--job", default=None, help="BIT job id to run (omit to list)")
 p.add_argument("--small", action="store_true", help=f"Only use the first {SMALL_MAX_EVENTS} selected events")
+p.add_argument("--uncertainty", action="store_true", help=f"Plot uncertainties?")
 args = p.parse_args()
 
 
@@ -148,10 +163,7 @@ def list_and_exit():
     raise RuntimeError(f"Loader/view '{loader_name}' not found in module {module_samples}.")
 L = getattr(samples_mod, loader_name)
 
-if args.small:
-    L.set_n_split(100)
-else:
-    L.set_n_split(20)
+L.set_n_split(100)
 
 sel = J.get("selection", None)
 sel_f = J.get("selection_features", [])
@@ -178,6 +190,28 @@ def list_and_exit():
 
 print(f"Plottable features: {plot_feats}")
 
+# --------------------------------------------------------------------------------
+# Uncertainty helpers 
+# --------------------------------------------------------------------------------
+if args.uncertainty:
+    def make_column_mask(all_features, wanted_features):
+        pos = {f: i for i, f in enumerate(all_features)}
+        mask = np.zeros(len(all_features), dtype=bool)
+        for f in wanted_features:
+            mask[pos[f]] = True
+        return mask
+
+    def nuis_to_A_matrix(combinations, nuisance_toys, nuisance_name_to_idx):
+        if not combinations:
+            return np.zeros((nuisance_toys.shape[0], 0), dtype=np.float64)
+
+        out = np.empty((nuisance_toys.shape[0], len(combinations)), dtype=np.float64)
+        for i_comb, comb in enumerate(combinations):
+            v = np.ones(nuisance_toys.shape[0], dtype=np.float64)
+            for p in comb:
+                v *= nuisance_toys[:, nuisance_name_to_idx[p]]
+            out[:, i_comb] = v
+        return out
 
 # --------------------------------------------------------------------------------
 # UID split config
@@ -307,7 +341,7 @@ def list_and_exit():
 # output directory
 # --------------------------------------------------------------------------------
 
-out_dir = os.path.join(user.plot_directory, "BIT-plot", cfg_base, J["id"])
+out_dir = os.path.join(user.plot_directory, "BIT-plot"+("_unc" if args.uncertainty else ""), cfg_base, J["id"])
 
 if args.small:
     out_dir = os.path.join(out_dir, "small")
@@ -315,6 +349,114 @@ def list_and_exit():
 
 print(f"Output directory: {out_dir}")
 
+# --------------------------------------------------------------------------------
+# uncertainty setup
+# --------------------------------------------------------------------------------
+
+if args.uncertainty:
+    yaml_loader.load_surrogates(CFG, cfg_path, overwrite=False)
+    uncertainty_like_info = load_likelihood(CFG)
+    uncertainty_hyp = build_hypothesis_from_likelihood(uncertainty_like_info, name=J["region"])
+
+    uncertainty_region = next(r for r in uncertainty_like_info["regions"] if r["id"] == J["region"])
+    uncertainty_classes = list(uncertainty_region.get("classes", []) or [])
+    uncertainty_classifier = (uncertainty_region.get("classifier") or {}).get("predictor", None)
+
+    uncertainty_nuisances = [par for par in uncertainty_hyp.nuisances if not par.isFrozen]
+    uncertainty_nuisance_names = [par.name for par in uncertainty_nuisances]
+    uncertainty_nuisance_name_to_idx = {name: i for i, name in enumerate(uncertainty_nuisance_names)}
+    uncertainty_n_nuisances = len(uncertainty_nuisance_names)
+
+    uncertainty_mean = np.full(uncertainty_n_nuisances, NUISANCE_TOY_MEAN, dtype=np.float64)
+    uncertainty_cov = np.eye(uncertainty_n_nuisances, dtype=np.float64) * (NUISANCE_TOY_SIGMA ** 2)
+
+    np.random.seed(NUISANCE_TOY_RNG_SEED)
+    uncertainty_toys = np.random.multivariate_normal(
+        mean=uncertainty_mean,
+        cov=uncertainty_cov,
+        size=NUISANCE_N_TOYS,
+    )
+
+    if uncertainty_classifier is not None:
+        uncertainty_classifier_column_mask = make_column_mask(feat_names, uncertainty_classifier.feature_names)
+    else:
+        uncertainty_classifier_column_mask = None
+
+    uncertainty_class_infos = []
+    for i_class, C in enumerate(uncertainty_classes):
+        class_info = {
+            "id": C["id"],
+            "index": i_class,
+            "pnn": [],
+            "lnN": [],
+        }
+
+        for S in (C.get("systematics") or []):
+#            if S.get("type") == "pnn":
+#                column_mask = make_column_mask(feat_names, S["predictor"].feature_names)
+#                nuA_toys = nuis_to_A_matrix(
+#                    [tuple(c) for c in (S.get("combinations") or [])],
+#                    uncertainty_toys,
+#                    uncertainty_nuisance_name_to_idx,
+#                )
+#                class_info["pnn"].append({
+#                    "id": S["id"],
+#                    "predictor": S["predictor"],
+#                    "column_mask": column_mask,
+#                    "nuA_toys": nuA_toys,
+#                })
+            # clipping for uncertainty evaluation
+            if S.get("type") == "pnn":
+                pnn_feature_names = list(S["predictor"].feature_names)
+                column_mask = make_column_mask(feat_names, pnn_feature_names)
+
+                clip_low = np.array(
+                    [PLOT_OPTS[name]["binning"][1] for name in pnn_feature_names],
+                    dtype=np.float64,
+                )
+                clip_high = np.array(
+                    [PLOT_OPTS[name]["binning"][2] for name in pnn_feature_names],
+                    dtype=np.float64,
+                )
+
+                nuA_toys = nuis_to_A_matrix(
+                    [tuple(c) for c in (S.get("combinations") or [])],
+                    uncertainty_toys,
+                    uncertainty_nuisance_name_to_idx,
+                )
+
+                class_info["pnn"].append({
+                    "id": S["id"],
+                    "predictor": S["predictor"],
+                    "column_mask": column_mask,
+                    "clip_low": clip_low,
+                    "clip_high": clip_high,
+                    "nuA_toys": nuA_toys,
+                })
+            elif S.get("type") == "lnN":
+                class_info["lnN"].append(
+                    (S["parameters"][0], math.log1p(float(S.get("value", 0.0))))
+                )
+
+        uncertainty_class_infos.append(class_info)
+
+    uncertainty_n_toys = uncertainty_toys.shape[0]
+    print("sampling done")
+
+else:
+    uncertainty_like_info = None
+    uncertainty_hyp = None
+    uncertainty_region = None
+    uncertainty_classes = []
+    uncertainty_classifier = None
+    uncertainty_classifier_column_mask = None
+    uncertainty_nuisances = []
+    uncertainty_nuisance_names = []
+    uncertainty_nuisance_name_to_idx = {}
+    uncertainty_toys = np.empty((0, 0), dtype=np.float64)
+    uncertainty_class_infos = []
+    uncertainty_n_toys = 0
+
 
 # --------------------------------------------------------------------------------
 # histogram containers
@@ -323,6 +465,7 @@ def list_and_exit():
 feature_columns = {f: feat_names.index(f) for f in plot_feats}
 feature_edges = {}
 nominal_hists = {}
+nominal_toy_hists = {}
 truth_num_hists = {}
 pred_num_hists = {}
 
@@ -331,6 +474,7 @@ def list_and_exit():
     edges = np.linspace(x_lo, x_hi, n_bins + 1, dtype=np.float64)
     feature_edges[feat] = edges
     nominal_hists[feat] = np.zeros(n_bins, dtype=np.float64)
+    nominal_toy_hists[feat] = np.zeros((n_bins, uncertainty_n_toys), dtype=np.float64)
     truth_num_hists[feat] = {der: np.zeros(n_bins, dtype=np.float64) for der in plot_derivatives}
     pred_num_hists[feat] = {der: np.zeros(n_bins, dtype=np.float64) for der in plot_derivatives}
 
@@ -389,6 +533,43 @@ def list_and_exit():
     if len(X) == 0:
         continue
 
+    if args.uncertainty:
+        if uncertainty_classifier is None or len(uncertainty_class_infos) <= 1:
+            uncertainty_g = np.ones((len(X), len(uncertainty_class_infos)), dtype=np.float64)
+        else:
+            uncertainty_g = _predict_classifier(
+                uncertainty_classifier,
+                X[:, uncertainty_classifier_column_mask],
+            )
+
+        uncertainty_T = np.zeros((len(X), uncertainty_n_toys), dtype=np.float64)
+
+        for class_info in uncertainty_class_infos:
+            g_cls = uncertainty_g[:, class_info["index"]].astype(np.float64, copy=False)
+            expo = np.zeros((len(X), uncertainty_n_toys), dtype=np.float64)
+
+            for syst_info in class_info["pnn"]:
+                X_syst = X[:, syst_info["column_mask"]].astype(np.float64, copy=True)
+                np.clip(X_syst, syst_info["clip_low"], syst_info["clip_high"], out=X_syst)
+
+                dA = predict_pnn_deltaA(
+                    syst_info["predictor"],
+                    X_syst,
+                )
+                expo += dA @ syst_info["nuA_toys"].T
+
+            ln_bias = np.zeros(uncertainty_n_toys, dtype=np.float64)
+            for pname, log1p_alpha in class_info["lnN"]:
+                ln_bias += log1p_alpha * uncertainty_toys[:, uncertainty_nuisance_name_to_idx[pname]]
+
+            exp_expo = np.exp(expo + ln_bias.reshape(1, -1))
+            uncertainty_T += g_cls.reshape(-1, 1) * (exp_expo - 1.0)
+
+        uncertainty_R = 1.0 + uncertainty_T
+
+    else:
+        uncertainty_R = np.empty((len(X), 0), dtype=np.float64)
+
     Q = G[:, i_Q].astype(np.float32, copy=False)
     x1 = G[:, i_x1].astype(np.float32, copy=False)
     x2 = G[:, i_x2].astype(np.float32, copy=False)
@@ -400,6 +581,91 @@ def list_and_exit():
 
     nominal_w = deriv_w[:, nominal_idx]
 
+    if uncertainty_R.shape[1] > 0:
+        toy_weights = nominal_w.reshape(-1, 1) * uncertainty_R
+
+        bad_mask = (~np.isfinite(toy_weights)) | (np.abs(toy_weights) > 1e4)
+        if np.any(bad_mask):
+            bad_idx = np.argwhere(bad_mask)
+            print("outlier toy weights:")
+            for i_evt, i_toy in bad_idx[:10]:
+                feat_str = ", ".join(
+                    f"{name}={X[i_evt, i_feat]:.6e}"
+                    for i_feat, name in enumerate(feat_names)
+                )
+
+                print(
+                    f"  shard={shard} evt={i_evt} toy={i_toy} "
+                    f"w0={nominal_w[i_evt]:.6e} "
+                    f"R={uncertainty_R[i_evt, i_toy]:.6e} "
+                    f"w={toy_weights[i_evt, i_toy]:.6e}"
+                )
+                print(f"    features: {feat_str}")
+
+                for class_info in uncertainty_class_infos:
+                    g_val = uncertainty_g[i_evt, class_info["index"]]
+
+                    ln_bias_terms = []
+                    ln_bias_val = 0.0
+                    for pname, log1p_alpha in class_info["lnN"]:
+                        term = log1p_alpha * uncertainty_toys[i_toy, uncertainty_nuisance_name_to_idx[pname]]
+                        ln_bias_terms.append((pname, term))
+                        ln_bias_val += term
+
+                    syst_terms = []
+                    expo_val = 0.0
+                    for syst_info in class_info["pnn"]:
+                        X_evt_raw = X[i_evt:i_evt+1, syst_info["column_mask"]].astype(np.float64, copy=True)
+                        X_evt = X_evt_raw.copy()
+                        np.clip(X_evt, syst_info["clip_low"], syst_info["clip_high"], out=X_evt)
+
+                        dA_evt = predict_pnn_deltaA(
+                            syst_info["predictor"],
+                            X_evt,
+                        )[0]
+                        nuA_toy = syst_info["nuA_toys"][i_toy]
+                        term = float(np.dot(dA_evt, nuA_toy))
+                        syst_terms.append((syst_info["id"], term))
+                        expo_val += term
+
+                        if np.any(X_evt != X_evt_raw):
+                            used_names = list(syst_info["predictor"].feature_names)
+                            raw_str = ", ".join(
+                                f"{name}={X_evt_raw[0, j]:.6e}"
+                                for j, name in enumerate(used_names)
+                            )
+                            clip_str = ", ".join(
+                                f"{name}={X_evt[0, j]:.6e}"
+                                for j, name in enumerate(used_names)
+                            )
+                            print(f"      syst {syst_info['id']} input clipped")
+                            print(f"        raw : {raw_str}")
+                            print(f"        clip: {clip_str}")
+
+                    arg_val = expo_val + ln_bias_val
+                    exp_val = np.exp(arg_val) if np.isfinite(arg_val) else np.nan
+                    class_contribution = g_val * (exp_val - 1.0) if np.isfinite(exp_val) else np.nan
+
+                    print(
+                        f"    class={class_info['id']} "
+                        f"g={g_val:.6e} "
+                        f"expo={expo_val:.6e} "
+                        f"ln_bias={ln_bias_val:.6e} "
+                        f"arg={arg_val:.6e} "
+                        f"exp(arg)={exp_val:.6e} "
+                        f"class_term={class_contribution:.6e}"
+                    )
+
+                    syst_terms = sorted(syst_terms, key=lambda x: abs(x[1]), reverse=True)
+                    for sid, term in syst_terms[:5]:
+                        print(f"      syst {sid}: {term:.6e}")
+
+                    ln_bias_terms = sorted(ln_bias_terms, key=lambda x: abs(x[1]), reverse=True)
+                    for pname, term in ln_bias_terms[:5]:
+                        print(f"      lnN  {pname}: {term:.6e}")
+    else:
+        toy_weights = np.empty((len(X), 0), dtype=np.float64)
+
     pred = np.asarray(bit.predict(X, max_n_tree=n_loaded_trees))
     if pred.ndim == 1:
         pred = pred.reshape(-1, 1)
@@ -410,6 +676,14 @@ def list_and_exit():
 
         nominal_hists[feat] += np.histogram(xvals, bins=edges, weights=nominal_w)[0]
 
+        if toy_weights.shape[1] > 0:
+            for i_toy in range(uncertainty_n_toys):
+                nominal_toy_hists[feat][:, i_toy] += np.histogram(
+                    xvals,
+                    bins=edges,
+                    weights=toy_weights[:, i_toy],
+                )[0]
+
         for der in plot_derivatives:
             truth_col = combo_to_idx[der]
             pred_col = pred_derivative_to_idx[der]
@@ -435,6 +709,10 @@ def list_and_exit():
 print(f"Processed {selected_events} selected events")
 
 
+# --------------------------------------------------------------------------------
+# plots: one feature per canvas
+# --------------------------------------------------------------------------------
+
 # --------------------------------------------------------------------------------
 # plots: one feature per canvas
 # --------------------------------------------------------------------------------
@@ -447,6 +725,15 @@ def list_and_exit():
     x_title = PLOT_OPTS[feat]["tex"]
 
     nominal = nominal_hists[feat]
+    nominal_toys = nominal_toy_hists[feat]
+    have_uncertainty = nominal_toys.shape[1] > 0
+
+    if have_uncertainty:
+        nominal_q_low = np.quantile(nominal_toys, 0.16, axis=1)
+        nominal_q_high = np.quantile(nominal_toys, 0.84, axis=1)
+    else:
+        nominal_q_low = None
+        nominal_q_high = None
 
     coeff_truth = {}
     coeff_pred = {}
@@ -485,10 +772,6 @@ def list_and_exit():
         right_min -= 0.5 * width
         right_max += 0.5 * width
 
-    #right_pad = 0.18 * (right_max - right_min)
-    #right_min -= right_pad
-    #right_max += right_pad
-
     right_pad_lo = 0.18 * (right_max - right_min)
     right_pad_hi = 0.28 * (right_max - right_min)
     right_min -= right_pad_lo
@@ -497,10 +780,15 @@ def list_and_exit():
     left_max = float(np.max(nominal)) if len(nominal) else 0.0
     if left_max <= 0.0:
         left_max = 1.0
-
-    #left_max *= 1.25
     left_max *= 1.35
 
+    #left_max = float(np.max(nominal)) if len(nominal) else 0.0
+    #if have_uncertainty:
+    #    left_max = max(left_max, float(np.max(nominal_q_high)))
+    #if left_max <= 0.0:
+    #    left_max = 1.0
+    #left_max *= 1.35
+
     canvas = ROOT.TCanvas(f"c_{feat}", feat, 900, 700)
     canvas.SetLeftMargin(0.13)
     canvas.SetRightMargin(0.14)
@@ -521,13 +809,39 @@ def list_and_exit():
     frame.Draw("axis")
     frame.GetYaxis().SetTicks("-")
 
+    drawn_objects = [frame]
+
+    if have_uncertainty:
+        uncertainty_boxes = []
+        for i_bin in range(n_bins):
+            box = ROOT.TBox(
+                float(edges[i_bin]),
+                float(nominal_q_low[i_bin]),
+                float(edges[i_bin + 1]),
+                float(nominal_q_high[i_bin]),
+            )
+            box.SetLineWidth(0)
+            box.SetLineColor(0)
+            box.SetFillColorAlpha(ROOT.kGray + 1, 0.35)
+            uncertainty_boxes.append(box)
+
+        for box in uncertainty_boxes:
+            box.Draw("same")
+
+        drawn_objects.extend(uncertainty_boxes)
+
     h_nominal = make_root_hist(f"h_nominal_{feat}", "", edges, nominal)
     h_nominal.SetLineColor(ROOT.kGray + 2)
     h_nominal.SetLineWidth(2)
-    h_nominal.SetFillColorAlpha(ROOT.kGray + 1, 0.35)
-    h_nominal.Draw("hist same")
 
-    drawn_objects = [frame, h_nominal]
+    if have_uncertainty:
+        h_nominal.SetFillStyle(0)
+        h_nominal.SetFillColor(0)
+    else:
+        h_nominal.SetFillColorAlpha(ROOT.kGray + 1, 0.35)
+
+    h_nominal.Draw("hist same")
+    drawn_objects.append(h_nominal)
 
     for der in plot_derivatives:
         y_truth_left = map_right_to_left(coeff_truth[der], right_min, right_max, left_max)
@@ -594,7 +908,12 @@ def list_and_exit():
 legend_frame.GetYaxis().SetTickLength(0.0)
 legend_frame.Draw("axis")
 
-legend_entries = 1 + 2 * len(plot_derivatives)
+legend_entries = 2 * len(plot_derivatives)
+if uncertainty_n_toys > 0:
+    legend_entries += 2
+else:
+    legend_entries += 1
+
 if legend_entries > 30:
     n_cols = 4
 elif legend_entries > 18:
@@ -615,9 +934,23 @@ def list_and_exit():
 dummy_nominal = ROOT.TH1D("dummy_nominal", "", 1, 0.0, 1.0)
 dummy_nominal.SetLineColor(ROOT.kGray + 2)
 dummy_nominal.SetLineWidth(2)
-dummy_nominal.SetFillColorAlpha(ROOT.kGray + 1, 0.35)
-legend.AddEntry(dummy_nominal, "SM distribution", "lf")
-legend_objects.append(dummy_nominal)
+
+if uncertainty_n_toys > 0:
+    dummy_nominal.SetFillStyle(0)
+    dummy_nominal.SetFillColor(0)
+    legend.AddEntry(dummy_nominal, "SM nominal", "l")
+
+    dummy_unc = ROOT.TH1D("dummy_unc", "", 1, 0.0, 1.0)
+    dummy_unc.SetLineWidth(0)
+    dummy_unc.SetLineColor(0)
+    dummy_unc.SetFillColorAlpha(ROOT.kGray + 1, 0.35)
+    legend.AddEntry(dummy_unc, "68% nuisance interval", "f")
+    legend_objects.extend([dummy_nominal, dummy_unc])
+
+else:
+    dummy_nominal.SetFillColorAlpha(ROOT.kGray + 1, 0.35)
+    legend.AddEntry(dummy_nominal, "SM distribution", "lf")
+    legend_objects.append(dummy_nominal)
 
 for der in plot_derivatives:
     label = derivative_label(der)
diff --git a/plot/bit/propaganda_plot_options.py b/plot/bit/propaganda_plot_options.py
index 31514eb..e00980b 100644
--- a/plot/bit/propaganda_plot_options.py
+++ b/plot/bit/propaganda_plot_options.py
@@ -181,8 +181,8 @@
     "tr_antinu_phi"               : { 'binning': [26,  -pi,   pi],   'tex': '#phi(#bar{#nu})',             'logY': False },
     "tr_antinu_mass"              : { 'binning': [50,   0,   100],   'tex': 'M(#bar{#nu})',                'logY': True  },
 
-    "tr_ttbar_pt"                 : { 'binning': [30,   0,  600],   'tex': 'p_{T}(t#bar{t})',             'logY': True  },
-    "tr_ttbar_mass"               : { 'binning': [29, 350,  1800],   'tex': 'M(t#bar{t})',                 'logY': True  },
+    "tr_ttbar_pt"                 : { 'binning': [30,   0,  600],    'tex': 'p_{T}(t#bar{t})',             'logY': False  },
+    "tr_ttbar_mass"               : { 'binning': [29, 350,  1800],   'tex': 'M(t#bar{t})',                 'logY': False  },
     "tr_ttbar_eta"                : { 'binning': [26,  -2.6,  2.6],  'tex': '#eta(t#bar{t})',              'logY': False },
     "tr_ttbar_phi"                : { 'binning': [26,  -pi,  pi],    'tex': '#phi(t#bar{t})',              'logY': False },
     "tr_ttbar_y"                  : { 'binning': [22,  -2.2,  2.2],  'tex': 'y(t#bar{t})',                 'logY': False },

From bcc548211a55eee2313c2ddc5ea73d6fcfd096fd Mon Sep 17 00:00:00 2001
From: Ricardo Barrue <ricardo.barrue@cern.ch>
Date: Sat, 18 Apr 2026 14:23:02 +0200
Subject: [PATCH 03/17] Fit comparison plots: fixing saving call to use syncer

---
 plot/postfitsys/compare_correlations.py | 12 ++++++------
 plot/postfitsys/compare_fits.py         | 13 ++++++-------
 2 files changed, 12 insertions(+), 13 deletions(-)

diff --git a/plot/postfitsys/compare_correlations.py b/plot/postfitsys/compare_correlations.py
index 8970e7b..72d50c4 100644
--- a/plot/postfitsys/compare_correlations.py
+++ b/plot/postfitsys/compare_correlations.py
@@ -61,11 +61,11 @@ def create_comparison_canvas(
     for axis, image in zip(axes, images):
         fig.colorbar(image, ax=axis, fraction=0.046, pad=0.04)
 
-    fig.tight_layout()
+    plt.tight_layout()
 
     os.makedirs(output_dir, exist_ok=True)
-    fig.savefig(os.path.join(output_dir, "correlation_comparison.png"), dpi=150, bbox_inches="tight")
-    fig.savefig(os.path.join(output_dir, "correlation_comparison.pdf"), bbox_inches="tight")
+    plt.savefig(os.path.join(output_dir, "correlation_comparison.png"), dpi=150, bbox_inches="tight")
+    plt.savefig(os.path.join(output_dir, "correlation_comparison.pdf"), bbox_inches="tight")
     plt.close(fig)
 
 
@@ -91,11 +91,11 @@ def create_difference_heatmap(
     ax.set_yticklabels(order, fontsize=6)
 
     fig.colorbar(image, ax=ax, fraction=0.046, pad=0.04)
-    fig.tight_layout()
+    plt.tight_layout()
 
     os.makedirs(output_dir, exist_ok=True)
-    fig.savefig(os.path.join(output_dir, "correlation_difference.png"), dpi=150, bbox_inches="tight")
-    fig.savefig(os.path.join(output_dir, "correlation_difference.pdf"), bbox_inches="tight")
+    plt.savefig(os.path.join(output_dir, "correlation_difference.png"), dpi=150, bbox_inches="tight")
+    plt.savefig(os.path.join(output_dir, "correlation_difference.pdf"), bbox_inches="tight")
     plt.close(fig)
 
 
diff --git a/plot/postfitsys/compare_fits.py b/plot/postfitsys/compare_fits.py
index 05c88ee..2cb89c7 100644
--- a/plot/postfitsys/compare_fits.py
+++ b/plot/postfitsys/compare_fits.py
@@ -87,17 +87,19 @@ def create_comparison_plot(
     ax.set_xlabel('Parameter value', fontsize=11)
     ax.legend(loc='upper right', fontsize=10)
     ax.grid(axis='x', alpha=0.3)
+    ax.set_xlim(-5.0,5.0)
     ax.axvline(x=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5)
     
-    fig.tight_layout()
+    plt.tight_layout()
     
     os.makedirs(output_dir, exist_ok=True)
     
-    fig.savefig(output_dir + '/fit_comparison.png', dpi=150, bbox_inches='tight')
-    fig.savefig(output_dir + '/fit_comparison.pdf', bbox_inches='tight')
+    plt.savefig(output_dir + '/fit_comparison.png', dpi=150, bbox_inches='tight')
+    plt.savefig(output_dir + '/fit_comparison.pdf', bbox_inches='tight')
     plt.close(fig)
 
-def main():
+if __name__ == '__main__':
+    
     parser = argparse.ArgumentParser(
         description='Compare fit results across multiple JSON files'
     )
@@ -129,6 +131,3 @@ def main():
     
     create_comparison_plot(args.fit_files, output_dir, args.blind)
     print(f"Plots saved to {output_dir}")
-
-if __name__ == '__main__':
-    main()

From f6963520ef275c81e5eebea6611ede6a3361279b Mon Sep 17 00:00:00 2001
From: Ricardo Barrue <ricardo.barrue@cern.ch>
Date: Sat, 18 Apr 2026 14:23:23 +0200
Subject: [PATCH 04/17] PDF eigenmode plotting: simpler version for CMS

---
 plot/pdf/pdf_eigenmode_plots.py | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/plot/pdf/pdf_eigenmode_plots.py b/plot/pdf/pdf_eigenmode_plots.py
index 2e27a47..7f2f328 100644
--- a/plot/pdf/pdf_eigenmode_plots.py
+++ b/plot/pdf/pdf_eigenmode_plots.py
@@ -79,27 +79,27 @@ def plot_unit_modes(x_vals: np.ndarray, pdf_central: np.ndarray,
         color = f"C{mode_idx % 10}"
         linestyle = linestyles[mode_idx % 4]
         pdf_variant = pdfs_unit[mode_label]
-        ax_top.semilogx(x_vals, pdf_variant, color=color, linestyle=linestyle, linewidth=1.5, label=f'EV({mode_idx+1})')
+        ax_top.semilogx(x_vals, pdf_variant, color=color, linestyle=linestyle, linewidth=1.5, label=f'EV({mode_idx})')
         
         mask = pdf_central > 1e-15
         ratio = np.ones_like(pdf_central)
         ratio[mask] = pdf_variant[mask] / pdf_central[mask]
-        ax_bot.semilogx(x_vals, ratio, color=color, linestyle=linestyle, linewidth=1.5, label=f'EV({mode_idx+1})')
+        ax_bot.semilogx(x_vals, ratio, color=color, linestyle=linestyle, linewidth=1.5, label=f'EV({mode_idx})')
         ax_bot.set_ylim(-1.0,4.0)
     
-    ax_top.set_ylabel(r'$g$')
-    ax_top.legend(loc='best', ncol=2, fontsize=18)
+    ax_top.set_ylabel(r'$xg$')
+    ax_top.legend(loc='best', ncol=2, fontsize=14)
     ax_top.grid(True, alpha=0.3, which='both')
     
     ax_bot.axhline(1.0, color='k', linestyle='--', linewidth=1, alpha=0.25)
     ax_bot.set_xlabel(r'$x$')
     ax_bot.set_ylabel(r'$g/g^{(ref)}$')
-    ax_bot.legend(loc='best', ncol=2, fontsize=18)
     ax_bot.grid(True, alpha=0.3, which='both')
     
     filename = os.path.join(output_dir, f'eigenmodes_d1_Q{int(Q_val*1000)}.png')
     plt.savefig(filename, dpi=150, bbox_inches='tight')
     plt.savefig(filename.replace(".png",".pdf"), dpi=150, bbox_inches='tight')
+    plt.savefig(filename.replace(".png",".svg"), dpi=150, bbox_inches='tight')
     plt.close()
     logger.info(f"Saved: {filename}")
 
@@ -133,7 +133,7 @@ def plot_sigma_modes(x_vals: np.ndarray, pdf_central: np.ndarray,
 
         ax_top.fill_between(x_vals, pdfs_minus[mode_label], pdfs_plus[mode_label], 
         color=color, alpha=0.08, linewidth=1.5, linestyle=linestyle)
-        ax_top.semilogx(x_vals, pdfs_plus[mode_label], linestyle=linestyle, color=color, linewidth=1.5, label=f'EV({mode_idx+1})', zorder=3)
+        ax_top.semilogx(x_vals, pdfs_plus[mode_label], linestyle=linestyle, color=color, linewidth=1.5, label=f'EV({mode_idx})', zorder=3)
         ax_top.semilogx(x_vals, pdfs_minus[mode_label], linestyle=linestyle, color=color, linewidth=1.5, zorder=3)
         
         mask = pdf_central > 1e-15
@@ -144,25 +144,25 @@ def plot_sigma_modes(x_vals: np.ndarray, pdf_central: np.ndarray,
         ratio_plus[mask] = pdfs_plus[mode_label][mask] / pdf_central[mask]
         
         ax_bot.fill_between(x_vals, ratio_minus, ratio_plus, color=color, alpha=0.08)
-        ax_bot.semilogx(x_vals, ratio_plus, color=color, linestyle=linestyle, linewidth=1.5, label=f'EV({mode_idx+1})', zorder=3)
+        ax_bot.semilogx(x_vals, ratio_plus, color=color, linestyle=linestyle, linewidth=1.5, label=f'EV({mode_idx})', zorder=3)
         ax_bot.semilogx(x_vals, ratio_minus, color=color, linestyle=linestyle, linewidth=1.5, zorder=3)
 
         ax_bot.set_xscale("log")
         ax_bot.set_ylim(0.9,1.10)
     
-    ax_top.set_ylabel(r'$g$')
-    ax_top.legend(loc='best', ncol=2, fontsize=18)
+    ax_top.set_ylabel(r'$xg$')
+    ax_top.legend(loc='best', ncol=2, fontsize=14)
     ax_top.grid(True, alpha=0.3, which='both')
     
     ax_bot.axhline(1.0, color='k', linestyle='--', linewidth=1, alpha=0.25)
     ax_bot.set_xlabel(r'$x$')
     ax_bot.set_ylabel(r'$g/g^{(ref)}$')
-    ax_bot.legend(loc='best', ncol=2, fontsize=18)
     ax_bot.grid(True, alpha=0.3, which='both')
     
     filename = os.path.join(output_dir, f'eigenmodes_sigma_d_Q{int(Q_val*1000)}.png')
     plt.savefig(filename, dpi=150, bbox_inches='tight')
     plt.savefig(filename.replace(".png",".pdf"), dpi=150, bbox_inches='tight')
+    plt.savefig(filename.replace(".png",".svg"), dpi=150, bbox_inches='tight')
     plt.close()
     logger.info(f"Saved: {filename}")
 

From 1791cd53b441cc4510eb4516f3ec61f5167d96bb Mon Sep 17 00:00:00 2001
From: Ricardo Barrue <ricardo.barrue@cern.ch>
Date: Sat, 18 Apr 2026 14:23:55 +0200
Subject: [PATCH 05/17] Prefit plotting: fixes

---
 user/robert/prefit_sys_binned.py | 14 ++++----
 user/robert/variations.py        | 61 ++++++++++++++------------------
 2 files changed, 34 insertions(+), 41 deletions(-)

diff --git a/user/robert/prefit_sys_binned.py b/user/robert/prefit_sys_binned.py
index 46134d9..37f471f 100644
--- a/user/robert/prefit_sys_binned.py
+++ b/user/robert/prefit_sys_binned.py
@@ -38,7 +38,7 @@
 p.add_argument("--branches_for_selection", nargs="+", default=["lep1_pt", "tr_isvalid", "isOS", "offZ"],
                help="branches we need to make the selection")
 p.add_argument("--features", nargs="+", default=[],
-               help="branches we need to make the selection")
+               help="branches we want to plot")
 p.add_argument("--templates", nargs="*", default=None,
                help="Make per-variation template plots for the given process(es). "
                     "If passed without values, defaults to TTLep_pow.")
@@ -54,17 +54,17 @@
 # User-editable config (in IPython you can override before %run -i)
 # -----------------------------------------------------------------------------
 #base = "/groups/hephy/cms/robert.schoefbeck/CMGRDF_ntuples/v2-3_nJ2p_nB2p_2l/"
-
-# (Ricardo) the .root files from make_ntuple live in
-# /groups/hephy/cms/ricardo.barrue/CMGRDF_ntuples_TotalJES_EtaSplit/v2-3-2_nJ2p_nB2p_2l/
-# the files with the variations are symlinked into Robert's base folder
 from data.samples_RunII import BASE_DIRECTORY
 base = str(BASE_DIRECTORY)
 
 eras = ["2016", "2016APV", "2017", "2018"]
-processes = ["TTLep_pow"]
+processes = ["TTLep_pow", "SingleTop", "TTSemi_pow", "DrellYan"]
+
+if args.processes:
+    processes = args.processes
+
 signals = []
-data = [] if args. doAsimov else ["Data"]
+data = [] if args.doAsimov else ["Data"]
 
 # shard splitting (default 10; override per-process if needed)
 N_SPLIT_DEFAULT = 1
diff --git a/user/robert/variations.py b/user/robert/variations.py
index da6d695..8235336 100644
--- a/user/robert/variations.py
+++ b/user/robert/variations.py
@@ -36,40 +36,33 @@
     'res4_2018'    : {'sys_up': 'CMS_res_j_4_2018_up', 'sys_down':'CMS_res_j_4_2018_down', 'eras':['2018']},
     'res5_2018'    : {'sys_up': 'CMS_res_j_5_2018_up', 'sys_down':'CMS_res_j_5_2018_down', 'eras':['2018']},
 
-#    'jes_b'        : {'sys_up': 'CMS_scale_j_FlavorPureBottom_up',      'sys_down': 'CMS_scale_j_FlavorPureBottom_down'},
-#    'jes_c'        : {'sys_up': 'CMS_scale_j_FlavorPureCharm_up',       'sys_down': 'CMS_scale_j_FlavorPureCharm_down'},
-#    'jeq_g'        : {'sys_up': 'CMS_scale_j_FlavorPureGluon_up',       'sys_down': 'CMS_scale_j_FlavorPureGluon_down'},
-#    'jes_q'        : {'sys_up': 'CMS_scale_j_FlavorPureQuark_up',       'sys_down': 'CMS_scale_j_FlavorPureQuark_down'},
-#    'jes_abs'      : {'sys_up': 'CMS_scale_j_Regrouped_Absolute_up',    'sys_down': 'CMS_scale_j_Regrouped_Absolute_down'},
-#    'jes_BBEC1'    : {'sys_up': 'CMS_scale_j_Regrouped_BBEC1_up',       'sys_down': 'CMS_scale_j_Regrouped_BBEC1_down'},
-#    'jes_EC2'      : {'sys_up': 'CMS_scale_j_Regrouped_EC2_up',         'sys_down': 'CMS_scale_j_Regrouped_EC2_down'},
-#    'jes_HF'       : {'sys_up': 'CMS_scale_j_Regrouped_HF_up',          'sys_down': 'CMS_scale_j_Regrouped_HF_down'},
-#    'jes_relbal'   : {'sys_up': 'CMS_scale_j_Regrouped_RelativeBal_up', 'sys_down': 'CMS_scale_j_Regrouped_RelativeBal_down'},
-#
-#    'jes_abs_16'   : {'sys_up': 'CMS_scale_j_Regrouped_Absolute_2016_up',       'sys_down': 'CMS_scale_j_Regrouped_Absolute_2016_down',       'eras':['2016APV', '2016']},
-#    'jes_BBEC1_16' : {'sys_up': 'CMS_scale_j_Regrouped_BBEC1_2016_up',          'sys_down': 'CMS_scale_j_Regrouped_BBEC1_2016_down',          'eras':['2016APV', '2016']},
-#    'jes_EC2_16'   : {'sys_up': 'CMS_scale_j_Regrouped_EC2_2016_up',            'sys_down': 'CMS_scale_j_Regrouped_EC2_2016_down',            'eras':['2016APV', '2016']},
-#    'jes_HF_16'    : {'sys_up': 'CMS_scale_j_Regrouped_HF_2016_up',             'sys_down': 'CMS_scale_j_Regrouped_HF_2016_down',             'eras':['2016APV', '2016']},
-#    'jes_relsam_16': {'sys_up': 'CMS_scale_j_Regrouped_RelativeSample_2016_up', 'sys_down': 'CMS_scale_j_Regrouped_RelativeSample_2016_down', 'eras':['2016APV', '2016']},
-#
-#    'jes_abs_17'   : {'sys_up': 'CMS_scale_j_Regrouped_Absolute_2017_up',        'sys_down':'CMS_scale_j_Regrouped_Absolute_2017_down',       'eras':['2017']},
-#    'jes_BBEC1_17' : {'sys_up': 'CMS_scale_j_Regrouped_BBEC1_2017_up',          'sys_down': 'CMS_scale_j_Regrouped_BBEC1_2017_down',          'eras':['2017']},
-#    'jes_EC2_17'   : {'sys_up': 'CMS_scale_j_Regrouped_EC2_2017_up',            'sys_down': 'CMS_scale_j_Regrouped_EC2_2017_down',            'eras':['2017']},
-#    'jes_HF_17'    : {'sys_up': 'CMS_scale_j_Regrouped_HF_2017_up',             'sys_down': 'CMS_scale_j_Regrouped_HF_2017_down',             'eras':['2017']},
-#    'jes_relsam_17': {'sys_up': 'CMS_scale_j_Regrouped_RelativeSample_2017_up', 'sys_down': 'CMS_scale_j_Regrouped_RelativeSample_2017_down', 'eras':['2017']},
-#
-#    'jes_abs_18'   : {'sys_up': 'CMS_scale_j_Regrouped_Absolute_2018_up',       'sys_down': 'CMS_scale_j_Regrouped_Absolute_2018_down',       'eras':['2018']},
-#    'jes_BBEC1_18' : {'sys_up': 'CMS_scale_j_Regrouped_BBEC1_2018_up',          'sys_down': 'CMS_scale_j_Regrouped_BBEC1_2018_down',          'eras':['2018']},
-#    'jes_EC2_18'   : {'sys_up': 'CMS_scale_j_Regrouped_EC2_2018_up',            'sys_down': 'CMS_scale_j_Regrouped_EC2_2018_down',            'eras':['2018']},
-#    'jes_HF_18'    : {'sys_up': 'CMS_scale_j_Regrouped_HF_2018_up',             'sys_down': 'CMS_scale_j_Regrouped_HF_2018_down',             'eras':['2018']},
-#    'jes_relsam_18': {'sys_up': 'CMS_scale_j_Regrouped_RelativeSample_2018_up', 'sys_down': 'CMS_scale_j_Regrouped_RelativeSample_2018_down', 'eras':['2018']},
-    
-    'jes_total_EtaBin0'        : {'sys_up': 'CMS_scale_j_Total_EtaBin0_up',      'sys_down': 'CMS_scale_j_Total_EtaBin0_down'},
-    'jes_total_EtaBin1'        : {'sys_up': 'CMS_scale_j_Total_EtaBin1_up',      'sys_down': 'CMS_scale_j_Total_EtaBin1_down'},
-    'jes_total_EtaBin2'        : {'sys_up': 'CMS_scale_j_Total_EtaBin2_up',      'sys_down': 'CMS_scale_j_Total_EtaBin2_down'},
-    'jes_total_EtaBin3'        : {'sys_up': 'CMS_scale_j_Total_EtaBin3_up',      'sys_down': 'CMS_scale_j_Total_EtaBin3_down'},
-    'jes_total_EtaBin4'        : {'sys_up': 'CMS_scale_j_Total_EtaBin4_up',      'sys_down': 'CMS_scale_j_Total_EtaBin4_down'},
-    'jes_total_EtaBin5'        : {'sys_up': 'CMS_scale_j_Total_EtaBin5_up',      'sys_down': 'CMS_scale_j_Total_EtaBin5_down'},
+   'jes_b'        : {'sys_up': 'CMS_scale_j_FlavorPureBottom_up',      'sys_down': 'CMS_scale_j_FlavorPureBottom_down'},
+   'jes_c'        : {'sys_up': 'CMS_scale_j_FlavorPureCharm_up',       'sys_down': 'CMS_scale_j_FlavorPureCharm_down'},
+   'jeq_g'        : {'sys_up': 'CMS_scale_j_FlavorPureGluon_up',       'sys_down': 'CMS_scale_j_FlavorPureGluon_down'},
+   'jes_q'        : {'sys_up': 'CMS_scale_j_FlavorPureQuark_up',       'sys_down': 'CMS_scale_j_FlavorPureQuark_down'},
+   'jes_abs'      : {'sys_up': 'CMS_scale_j_Regrouped_Absolute_up',    'sys_down': 'CMS_scale_j_Regrouped_Absolute_down'},
+   'jes_BBEC1'    : {'sys_up': 'CMS_scale_j_Regrouped_BBEC1_up',       'sys_down': 'CMS_scale_j_Regrouped_BBEC1_down'},
+   'jes_EC2'      : {'sys_up': 'CMS_scale_j_Regrouped_EC2_up',         'sys_down': 'CMS_scale_j_Regrouped_EC2_down'},
+   'jes_HF'       : {'sys_up': 'CMS_scale_j_Regrouped_HF_up',          'sys_down': 'CMS_scale_j_Regrouped_HF_down'},
+   'jes_relbal'   : {'sys_up': 'CMS_scale_j_Regrouped_RelativeBal_up', 'sys_down': 'CMS_scale_j_Regrouped_RelativeBal_down'},
+
+   'jes_abs_16'   : {'sys_up': 'CMS_scale_j_Regrouped_Absolute_2016_up',       'sys_down': 'CMS_scale_j_Regrouped_Absolute_2016_down',       'eras':['2016APV', '2016']},
+   'jes_BBEC1_16' : {'sys_up': 'CMS_scale_j_Regrouped_BBEC1_2016_up',          'sys_down': 'CMS_scale_j_Regrouped_BBEC1_2016_down',          'eras':['2016APV', '2016']},
+   'jes_EC2_16'   : {'sys_up': 'CMS_scale_j_Regrouped_EC2_2016_up',            'sys_down': 'CMS_scale_j_Regrouped_EC2_2016_down',            'eras':['2016APV', '2016']},
+   'jes_HF_16'    : {'sys_up': 'CMS_scale_j_Regrouped_HF_2016_up',             'sys_down': 'CMS_scale_j_Regrouped_HF_2016_down',             'eras':['2016APV', '2016']},
+   'jes_relsam_16': {'sys_up': 'CMS_scale_j_Regrouped_RelativeSample_2016_up', 'sys_down': 'CMS_scale_j_Regrouped_RelativeSample_2016_down', 'eras':['2016APV', '2016']},
+
+   'jes_abs_17'   : {'sys_up': 'CMS_scale_j_Regrouped_Absolute_2017_up',        'sys_down':'CMS_scale_j_Regrouped_Absolute_2017_down',       'eras':['2017']},
+   'jes_BBEC1_17' : {'sys_up': 'CMS_scale_j_Regrouped_BBEC1_2017_up',          'sys_down': 'CMS_scale_j_Regrouped_BBEC1_2017_down',          'eras':['2017']},
+   'jes_EC2_17'   : {'sys_up': 'CMS_scale_j_Regrouped_EC2_2017_up',            'sys_down': 'CMS_scale_j_Regrouped_EC2_2017_down',            'eras':['2017']},
+   'jes_HF_17'    : {'sys_up': 'CMS_scale_j_Regrouped_HF_2017_up',             'sys_down': 'CMS_scale_j_Regrouped_HF_2017_down',             'eras':['2017']},
+   'jes_relsam_17': {'sys_up': 'CMS_scale_j_Regrouped_RelativeSample_2017_up', 'sys_down': 'CMS_scale_j_Regrouped_RelativeSample_2017_down', 'eras':['2017']},
+
+   'jes_abs_18'   : {'sys_up': 'CMS_scale_j_Regrouped_Absolute_2018_up',       'sys_down': 'CMS_scale_j_Regrouped_Absolute_2018_down',       'eras':['2018']},
+   'jes_BBEC1_18' : {'sys_up': 'CMS_scale_j_Regrouped_BBEC1_2018_up',          'sys_down': 'CMS_scale_j_Regrouped_BBEC1_2018_down',          'eras':['2018']},
+   'jes_EC2_18'   : {'sys_up': 'CMS_scale_j_Regrouped_EC2_2018_up',            'sys_down': 'CMS_scale_j_Regrouped_EC2_2018_down',            'eras':['2018']},
+   'jes_HF_18'    : {'sys_up': 'CMS_scale_j_Regrouped_HF_2018_up',             'sys_down': 'CMS_scale_j_Regrouped_HF_2018_down',             'eras':['2018']},
+   'jes_relsam_18': {'sys_up': 'CMS_scale_j_Regrouped_RelativeSample_2018_up', 'sys_down': 'CMS_scale_j_Regrouped_RelativeSample_2018_down', 'eras':['2018']},
 
     'jme_uncl'     : {'sys_up': 'Uncl_up', 'sys_down': 'Uncl_down'},
 

From 98370ff961a39be22f7ef58c295539c7bb829c26 Mon Sep 17 00:00:00 2001
From: Ricardo Barrue <ricardo.barrue@cern.ch>
Date: Sat, 18 Apr 2026 14:24:40 +0200
Subject: [PATCH 06/17] Postfit plot script: plot data

---
 plot/postfitsys/binned_fromfit.py | 120 +++++++++++++++++++++++++++++-
 1 file changed, 117 insertions(+), 3 deletions(-)

diff --git a/plot/postfitsys/binned_fromfit.py b/plot/postfitsys/binned_fromfit.py
index 9d9aa2f..3998e58 100644
--- a/plot/postfitsys/binned_fromfit.py
+++ b/plot/postfitsys/binned_fromfit.py
@@ -22,6 +22,7 @@
 from fit.Modeling import Rotated
 from data.plot_options import plot_options
 from data.colors import get_color
+import importlib
 
 ROOT.gROOT.SetBatch(True)
 ROOT.gStyle.SetOptStat(0)
@@ -110,6 +111,23 @@ def evaluate_class(cls, h_base):
 
 like_info = load_likelihood(cfg)
 hyp = build_hypothesis_from_likelihood(like_info, name="SR")
+
+is_data_fit = ("data" in args.fit_result)
+
+# grabbing sample factory to create data histograms downstream
+# may need to move this further down to use pieces of code
+# that get things that I need
+if is_data_fit:
+    from common.yaml_loader import _resolve_features_list
+    default_features = cfg["defaults"].get("default_features", None)
+    features = _resolve_features_list(default_features) if default_features else None
+    samples_mod = importlib.import_module(cfg["defaults"]["module_samples"])
+    factory = samples_mod.Factory(
+        features=features,
+        selection=cfg["defaults"].get("default_selection", None),
+        selection_features=cfg["defaults"].get("default_selection_features", None),
+    )
+
 rotated = bool(args.rotate)
 hyp_for_fit = Rotated(hyp, args.rotate, name="Fisher-basis") if rotated else hyp
 
@@ -168,6 +186,9 @@ def evaluate_class(cls, h_base):
     x_title_default = "bin"
     logY_default = False
 
+print(f"{default_binning=}")
+print(f"{var_name=}, {var_edges_default=}")
+
 base = os.path.splitext(os.path.basename(config_path))[0]
 version = str(cfg.get("version", "v0"))
 suffix = "_rotate" if rotated else ""
@@ -318,6 +339,84 @@ def evaluate_class(cls, h_base):
     h_unc_down.SetFillStyle(0)
 
     h_data = h_total.Clone(f"h_postfit_data_{_safe_name(region_id)}")
+
+    if not is_data_fit:
+        if 'data' in region:
+            print(f"[warning] data sample in region {region_id}, but fit result from MC-only fit. Plotting data as total MC.")
+        h_data = h_total.Clone(f"h_postfit_data_{_safe_name(region_id)}")
+    else:
+
+        if "data" not in region:
+            raise ValueError("Fit output from fit to data, but no data sample was defined in config.")
+
+        loader = factory.get(region["data"]["sample"])
+        region_binning = region.get("binning", default_binning)
+
+        if len(shape) != len(region_binning):
+            raise RuntimeError(
+                f"Region {region_id}: predictor dimension {len(shape)} does not match binning dimension {len(region_binning)}."
+            )
+
+        first_variable_name, first_variable_edges = region_binning[0]
+        first_variable_edges_array = np.asarray(first_variable_edges, dtype=np.float64)
+
+        if len(shape) == 1:
+            data_counts = np.zeros(len(first_variable_edges_array) - 1, dtype=np.float64)
+
+            # not really necessary to shard data, but I guess
+            # this will also work for larger toys so keeping here
+            for shard_index in range(len(loader)):
+                shard_features = loader.features(
+                    shard=shard_index,
+                    feature_names=[first_variable_name],
+                )
+                if shard_features.size == 0:
+                    continue
+                shard_histogram, _ = np.histogram(
+                    shard_features[:, 0],
+                    bins=first_variable_edges_array,
+                )
+                data_counts += shard_histogram
+
+            data_unrolled = data_counts
+
+        elif len(shape) == 2:
+            second_variable_name, second_variable_edges = region_binning[1]
+            second_variable_edges_array = np.asarray(second_variable_edges, dtype=np.float64)
+
+            data_counts_2d = np.zeros(
+                (len(first_variable_edges_array) - 1, len(second_variable_edges_array) - 1),
+                dtype=np.float64,
+            )
+
+            for shard_index in range(len(loader)):
+                shard_features = loader.features(
+                    shard=shard_index,
+                    feature_names=[first_variable_name, second_variable_name],
+                )
+                if shard_features.size == 0:
+                    continue
+                shard_histogram_2d, _, _ = np.histogram2d(
+                    shard_features[:, 0],
+                    shard_features[:, 1],
+                    bins=(first_variable_edges_array, second_variable_edges_array),
+                )
+                data_counts_2d += shard_histogram_2d
+
+            data_unrolled = data_counts_2d.reshape(-1)
+
+        else:
+            raise RuntimeError(f"Region {region_id}: only 1D/2D binning is supported, got shape={shape}.")
+
+        if len(data_unrolled) != n_bins_region:
+            raise RuntimeError(
+                f"Region {region_id}: data bins ({len(data_unrolled)}) do not match predictor bins ({n_bins_region})."
+            )
+
+        for ib, value in enumerate(data_unrolled, start=1):
+            print(f"data histogram: {ib=}, {value=}; {h_total.GetBinContent(ib)=}")
+            h_data.SetBinContent(ib, float(value))
+        
     h_data.SetDirectory(0)
     for ib in range(1, n_bins_region + 1):
         y = h_data.GetBinContent(ib)
@@ -329,14 +428,19 @@ def evaluate_class(cls, h_base):
 
     h_ratio_data = h_data.Clone(f"h_postfit_ratio_data_{_safe_name(region_id)}")
     h_ratio_data.SetDirectory(0)
+    
+    # in the case of Asimov, this will be equal to max_dev
+    max_dev_data = 0.0
     for ib in range(1, n_bins_region + 1):
         nom = h_total.GetBinContent(ib)
         y   = h_data.GetBinContent(ib)
-        ey  = h_data.GetBinError(ib)   # stat-only = sqrt(y)
+        ey  = h_data.GetBinError(ib)   # stat-only = sqrt(y) \  
 
         if nom > 0.0:
+            rel = ey/nom
             h_ratio_data.SetBinContent(ib, y / nom)
             h_ratio_data.SetBinError(ib, ey / nom)
+            max_dev_data = max(max_dev_data, rel)
         else:
             h_ratio_data.SetBinContent(ib, 0.0)
             h_ratio_data.SetBinError(ib, 0.0)
@@ -413,7 +517,10 @@ def evaluate_class(cls, h_base):
     leg.SetBorderSize(0)
     leg.SetFillStyle(0)
     leg.SetNColumns(2)
-    leg.AddEntry(h_data, "Data (Asimov)", "lep")
+    if is_data_fit:
+        leg.AddEntry(h_data, "Data", "lep")
+    else:
+        leg.AddEntry(h_data, "Data (Asimov)", "lep")
     for h, lbl in zip(class_hists_sorted, class_labels_sorted):
         leg.AddEntry(h, lbl, "f")
     leg.AddEntry(h_unc, "Uncertainty", "f")
@@ -432,7 +539,10 @@ def evaluate_class(cls, h_base):
     h_ratio.SetLineColor(ROOT.kBlack)
     h_ratio.SetLineWidth(2)
     h_ratio.SetTitle("")
-    h_ratio.GetYaxis().SetTitle("var / nominal")
+    if is_data_fit:
+        h_ratio.GetYaxis().SetTitle("data / MC")
+    else:
+        h_ratio.GetYaxis().SetTitle("var / nominal")
     h_ratio.GetYaxis().SetNdivisions(505)
     h_ratio.GetYaxis().SetTitleSize(0.09)
     h_ratio.GetYaxis().SetTitleOffset(0.5)
@@ -478,6 +588,10 @@ def evaluate_class(cls, h_base):
             h_ratio_up.SetBinContent(ib, 1.0)
             h_ratio_down.SetBinContent(ib, 1.0)
 
+    if is_data_fit:
+        max_dev = max_dev_data
+        print(f"{max_dev_data=}")    
+
     if max_dev <= 0.0:
         r_min, r_max = 0.9, 1.1
     else:

From 5577bb9ff204794325908970e628cf6d89743aac Mon Sep 17 00:00:00 2001
From: Ricardo Barrue <ricardo.barrue@cern.ch>
Date: Mon, 20 Apr 2026 11:31:03 +0200
Subject: [PATCH 07/17] BIT plots (from sbi-pdf)

---
 plot/bit/bit_plot.py                | 654 ++++++++++++++++++++++++++++
 plot/bit/propaganda_plot_options.py | 245 +++++++++++
 2 files changed, 899 insertions(+)
 create mode 100644 plot/bit/bit_plot.py
 create mode 100644 plot/bit/propaganda_plot_options.py

diff --git a/plot/bit/bit_plot.py b/plot/bit/bit_plot.py
new file mode 100644
index 0000000..9d6b532
--- /dev/null
+++ b/plot/bit/bit_plot.py
@@ -0,0 +1,654 @@
+#!/usr/bin/env python
+from __future__ import annotations
+
+import os
+import sys
+import math
+import argparse
+import importlib
+import itertools
+
+import numpy as np
+import ROOT
+from tqdm import tqdm
+
+# project roots
+sys.path.insert(0, "..")
+sys.path.insert(0, "../..")
+
+import common.user as user
+import common.yaml_loader as yaml_loader
+
+from pdf.PDFParametrization import PDFParametrization
+from ML.BIT.NumbaBIT import MultiBoostedInformationTree
+from data.UIDSplitter import UIDSplitter
+from propaganda_plot_options import plot_options as PLOT_OPTS
+import common.syncer as syncer
+import common.helpers as helpers
+# --------------------------------------------------------------------------------
+# hard-coded knobs
+# --------------------------------------------------------------------------------
+
+# Show all available derivatives by default.
+# To restrict the output, uncomment and edit, e.g.
+# SHOW_ONLY = [("c1",), ("c2",), ("c1", "c1"), ("c1", "c2")]
+SHOW_ONLY = [("c0",), ("c1",), ("c2",), ("c3",), ("c4",), ("c5",)]
+
+# --small will stop after this many selected events
+SMALL_MAX_EVENTS = 20000
+
+# More discernible hard-coded colors (Wong/Okabe-Ito style + a few extras)
+COLOR_HEX = [
+    "#0072B2",  # blue
+    "#D55E00",  # vermillion
+    "#009E73",  # bluish green
+    "#CC79A7",  # reddish purple
+    "#E69F00",  # orange
+    "#56B4E9",  # sky blue
+    "#F0E442",  # yellow
+    "#882255",  # wine
+    "#44AA99",  # teal
+    "#AA4499",  # magenta
+    "#117733",  # dark green
+    "#332288",  # dark blue
+]
+
+# Keep the plot logic in the main scope; only tiny utilities live here.
+def canonical_derivative(der):
+    der = tuple(der)
+    if len(der) <= 1:
+        return der
+    return tuple(sorted(der))
+
+def derivative_label(der):
+    if len(der) == 1:
+        return der[0]
+    if len(der) == 2 and der[0] == der[1]:
+        return f"{der[0]}^{{2}}"
+    if len(der) == 2:
+        return f"{der[0]} #times {der[1]}"
+    return str(der)
+
+def make_root_hist(name, title, edges, values):
+    h = ROOT.TH1D(name, title, len(edges) - 1, edges.astype(np.float64))
+    for i_bin, val in enumerate(values, start=1):
+        h.SetBinContent(i_bin, float(val))
+    return h
+
+def map_right_to_left(values, right_min, right_max, left_max):
+    out = np.zeros_like(values, dtype=np.float64)
+    if right_max <= right_min:
+        return out
+    out[:] = left_max * (values - right_min) / (right_max - right_min)
+    return out
+
+
+# --------------------------------------------------------------------------------
+# args
+# --------------------------------------------------------------------------------
+
+p = argparse.ArgumentParser(description="BIT plotting from a trained model (YAML-driven)")
+p.add_argument("config", help="Path to global YAML config")
+p.add_argument("--job", default=None, help="BIT job id to run (omit to list)")
+p.add_argument("--small", action="store_true", help=f"Only use the first {SMALL_MAX_EVENTS} selected events")
+args = p.parse_args()
+
+
+# --------------------------------------------------------------------------------
+# ROOT style
+# --------------------------------------------------------------------------------
+
+ROOT.gROOT.SetBatch(True)
+ROOT.gStyle.SetOptStat(0)
+ROOT.gStyle.SetTitleBorderSize(0)
+ROOT.gStyle.SetPadTickX(1)
+ROOT.gStyle.SetPadTickY(1)
+ROOT.gStyle.SetLegendBorderSize(0)
+ROOT.TGaxis.SetMaxDigits(3)
+
+# --------------------------------------------------------------------------------
+# cfg / job selection
+# --------------------------------------------------------------------------------
+
+cfg_path = os.path.expanduser(os.path.expandvars(args.config))
+CFG = yaml_loader.load_yaml(cfg_path)
+D = CFG.get("defaults", {}) or {}
+module_samples = D.get("module_samples", "data.samples")
+
+def list_and_exit():
+    jobs = [j for j in (CFG.get("jobs") or []) if j.get("type") == "bit"]
+    if not jobs:
+        print("No BIT jobs found.")
+        sys.exit(0)
+
+    script = os.path.basename(__file__)
+    flags = []
+    if args.small:
+        flags.append("--small")
+
+    for j in jobs:
+        print(f"python {script} {args.config} {' '.join(flags)} --job {j['id']}".strip())
+    sys.exit(0)
+
+if args.job is None:
+    list_and_exit()
+
+J = next((j for j in (CFG.get("jobs") or []) if j.get("id") == args.job), None)
+if J is None or J.get("type") != "bit":
+    raise RuntimeError(f"Job '{args.job}' not found or not type 'bit'.")
+
+
+# --------------------------------------------------------------------------------
+# loader
+# --------------------------------------------------------------------------------
+
+samples_mod = importlib.import_module(module_samples)
+loader_name = J.get("process")
+if not hasattr(samples_mod, loader_name):
+    raise RuntimeError(f"Loader/view '{loader_name}' not found in module {module_samples}.")
+L = getattr(samples_mod, loader_name)
+
+if args.small:
+    L.set_n_split(100)
+else:
+    L.set_n_split(20)
+
+sel = J.get("selection", None)
+sel_f = J.get("selection_features", [])
+if sel:
+    L.addSelection(sel, sel_f)
+    print(f"Added selection to loader: {sel} with selection_features {sel_f}")
+
+L.setFeatures(J["features"])
+
+feat_names = list(getattr(L, "feature_names", []) or [])
+if not feat_names:
+    raise RuntimeError("Loader has no feature_names.")
+
+GEN_OBS = ["Generator_x1", "Generator_x2", "Generator_id1", "Generator_id2", "Generator_scalePDF"]
+obs_names = list(getattr(L, "observer_names", []) or [])
+missing_gen = [n for n in GEN_OBS if n not in obs_names]
+if missing_gen:
+    raise RuntimeError(f"Observer_names must include {GEN_OBS}, missing {missing_gen} in loader '{loader_name}'.")
+
+plot_feats = [f for f in feat_names if f in PLOT_OPTS]
+if not plot_feats:
+    print("No plottable features found in data.plot_options. Nothing to do.")
+    sys.exit(0)
+
+print(f"Plottable features: {plot_feats}")
+
+
+# --------------------------------------------------------------------------------
+# UID split config
+# --------------------------------------------------------------------------------
+
+UID_CFG = (J.get("splitting") or {})
+uid_enabled = bool(UID_CFG.get("enabled", False))
+uid_fields = UID_CFG.get("uid_fields", ["run", "luminosityBlock", "event"])
+uid_seed = int(UID_CFG.get("seed", 0))
+uid_n_buckets = int(UID_CFG.get("n_buckets", 10000))
+uid_scheme = (UID_CFG.get("scheme") or {})
+
+uid_splitter = None
+train_interval = None
+
+if uid_enabled:
+    uid_splitter = UIDSplitter(
+        uid_fields=tuple(uid_fields),
+        seed=uid_seed,
+        n_buckets=uid_n_buckets,
+    )
+
+    keys = list(uid_scheme.keys())
+    fracs = [float((uid_scheme[k] or {}).get("fraction", 0.0)) for k in keys]
+
+    sizes = [int(math.floor(f * uid_n_buckets)) for f in fracs]
+    sizes[-1] += uid_n_buckets - sum(sizes)
+
+    uid_intervals = {}
+    lo = 0
+    for k, sz in zip(keys, sizes):
+        uid_intervals[k] = (lo, lo + int(sz))
+        lo += int(sz)
+
+    bit_train_key = "pnn_train"
+    if bit_train_key not in uid_intervals:
+        raise RuntimeError(f"UID split enabled, but '{bit_train_key}' was not found in the splitting scheme.")
+
+    train_interval = uid_intervals[bit_train_key]
+
+    print(f"[UID] enabled=True fields={uid_fields} seed={uid_seed} n_buckets={uid_n_buckets}")
+    print(f"[UID] scheme intervals: {uid_intervals}")
+    print(f"[UID] plotting split '{bit_train_key}' -> {train_interval}")
+else:
+    print("[UID] disabled -> plotting all selected events")
+
+
+# --------------------------------------------------------------------------------
+# PDF parametrization
+# --------------------------------------------------------------------------------
+
+pdf_n = J.get("pdf", {}).get("pdf_n", None)
+pdf_type = J.get("pdf", {}).get("pdf_type", None)
+pdf_basis = J.get("pdf", {}).get("pdf_basis", None)
+pdf_rescale_pod_amplitudes = J.get("pdf", {}).get("rescale_pod_amplitudes", True)
+
+pdf = PDFParametrization(
+    n=pdf_n,
+    typ=pdf_type,
+    basis=pdf_basis,
+    rescale_pod_amplitudes=pdf_rescale_pod_amplitudes,
+)
+
+combos = [canonical_derivative(c) for c in pdf.combinations]
+combo_to_idx = {c: i for i, c in enumerate(combos)}
+
+if () not in combo_to_idx:
+    raise RuntimeError("Could not find the nominal coefficient () in PDF combinations.")
+
+nominal_idx = combo_to_idx[()]
+
+
+# --------------------------------------------------------------------------------
+# model loading
+# --------------------------------------------------------------------------------
+
+cfg_base = os.path.join(CFG.get("version", "default"), J["region"])
+model_dir = os.path.join(user.model_directory, cfg_base, "BIT", J["id"])
+model_path = os.path.join(model_dir, J.get("output", {}).get("filename", "BIT.pkl"))
+
+print(f"Trying to load BIT from {model_path}")
+try:
+    bit = MultiBoostedInformationTree.load(model_path)
+except Exception as e:
+    print(f"Could not load BIT model from '{model_path}'.")
+    print(f"Reason: {e}")
+    sys.exit(1)
+
+n_loaded_trees = len(getattr(bit, "trees", []) or [])
+print(f"Loaded BIT model successfully: {n_loaded_trees} trees")
+
+model_derivatives_raw = list(getattr(bit, "derivatives", []) or [])
+if not model_derivatives_raw:
+    print("Loaded BIT model, but bit.derivatives is empty. Nothing to plot.")
+    sys.exit(1)
+
+model_derivatives = [canonical_derivative(d) for d in model_derivatives_raw]
+pred_derivative_to_idx = {}
+for i_der, der in enumerate(model_derivatives):
+    pred_derivative_to_idx[der] = i_der
+
+if SHOW_ONLY is None:
+    plot_derivatives = [d for d in model_derivatives if d in combo_to_idx]
+else:
+    plot_derivatives = []
+    for der in SHOW_ONLY:
+        cder = canonical_derivative(der)
+        if cder not in combo_to_idx:
+            print(f"Requested derivative {der} not available in PDF combinations -> skipping")
+            continue
+        if cder not in pred_derivative_to_idx:
+            print(f"Requested derivative {der} not available in loaded model -> skipping")
+            continue
+        if cder not in plot_derivatives:
+            plot_derivatives.append(cder)
+
+if not plot_derivatives:
+    print("No derivatives selected for plotting.")
+    sys.exit(1)
+
+print("Plotting derivatives:")
+for der in plot_derivatives:
+    print(f"  {der}")
+
+
+# --------------------------------------------------------------------------------
+# output directory
+# --------------------------------------------------------------------------------
+
+out_dir = os.path.join(user.plot_directory, "BIT-plot", cfg_base, J["id"])
+
+if args.small:
+    out_dir = os.path.join(out_dir, "small")
+os.makedirs(out_dir, exist_ok=True)
+
+print(f"Output directory: {out_dir}")
+
+
+# --------------------------------------------------------------------------------
+# histogram containers
+# --------------------------------------------------------------------------------
+
+feature_columns = {f: feat_names.index(f) for f in plot_feats}
+feature_edges = {}
+nominal_hists = {}
+truth_num_hists = {}
+pred_num_hists = {}
+
+for feat in plot_feats:
+    n_bins, x_lo, x_hi = PLOT_OPTS[feat]["binning"]
+    edges = np.linspace(x_lo, x_hi, n_bins + 1, dtype=np.float64)
+    feature_edges[feat] = edges
+    nominal_hists[feat] = np.zeros(n_bins, dtype=np.float64)
+    truth_num_hists[feat] = {der: np.zeros(n_bins, dtype=np.float64) for der in plot_derivatives}
+    pred_num_hists[feat] = {der: np.zeros(n_bins, dtype=np.float64) for der in plot_derivatives}
+
+root_colors = {}
+for i_der, der in enumerate(plot_derivatives):
+    root_colors[der] = ROOT.TColor.GetColor(COLOR_HEX[i_der % len(COLOR_HEX)])
+
+
+# --------------------------------------------------------------------------------
+# event loop
+# --------------------------------------------------------------------------------
+
+on2idx = {n: i for i, n in enumerate(obs_names)}
+
+i_Q = on2idx["Generator_scalePDF"]
+i_x1 = on2idx["Generator_x1"]
+i_x2 = on2idx["Generator_x2"]
+i_id1 = on2idx["Generator_id1"]
+i_id2 = on2idx["Generator_id2"]
+
+if uid_enabled:
+    uid_idx = [on2idx[f] for f in uid_fields]
+    lo_tr, hi_tr = train_interval
+
+selected_events = 0
+n_shards = len(L)
+
+for shard in tqdm(range(n_shards), desc="Shards", unit="shard"):
+    X, G, w = L.materialize(shard=shard, what="fow")
+
+    if len(X) == 0:
+        continue
+
+    if uid_enabled:
+        O_uid = G[:, uid_idx]
+        mask = uid_splitter.mask_from_np(O_uid, list(uid_fields), lo_tr, hi_tr)
+    else:
+        mask = np.ones(len(X), dtype=bool)
+
+    if not np.any(mask):
+        continue
+
+    X = X[mask].astype(np.float32, copy=False)
+    G = G[mask]
+    w = w[mask].astype(np.float32, copy=False)
+
+    if args.small:
+        remaining = SMALL_MAX_EVENTS - selected_events
+        if remaining <= 0:
+            break
+        if len(X) > remaining:
+            X = X[:remaining]
+            G = G[:remaining]
+            w = w[:remaining]
+
+    if len(X) == 0:
+        continue
+
+    Q = G[:, i_Q].astype(np.float32, copy=False)
+    x1 = G[:, i_x1].astype(np.float32, copy=False)
+    x2 = G[:, i_x2].astype(np.float32, copy=False)
+    id1 = G[:, i_id1].astype(np.int32, copy=False)
+    id2 = G[:, i_id2].astype(np.int32, copy=False)
+
+    deriv = pdf.derivatives(x1=x1, x2=x2, id1=id1, id2=id2, Q=Q).astype(np.float32, copy=False)
+    deriv_w = deriv * w.reshape(-1, 1)
+
+    nominal_w = deriv_w[:, nominal_idx]
+
+    pred = np.asarray(bit.predict(X, max_n_tree=n_loaded_trees))
+    if pred.ndim == 1:
+        pred = pred.reshape(-1, 1)
+
+    for feat in plot_feats:
+        xvals = X[:, feature_columns[feat]].astype(np.float64, copy=False)
+        edges = feature_edges[feat]
+
+        nominal_hists[feat] += np.histogram(xvals, bins=edges, weights=nominal_w)[0]
+
+        for der in plot_derivatives:
+            truth_col = combo_to_idx[der]
+            pred_col = pred_derivative_to_idx[der]
+
+            truth_num_hists[feat][der] += np.histogram(
+                xvals,
+                bins=edges,
+                weights=deriv_w[:, truth_col],
+            )[0]
+
+            pred_num_hists[feat][der] += np.histogram(
+                xvals,
+                bins=edges,
+                weights=nominal_w * pred[:, pred_col],
+            )[0]
+
+    selected_events += len(X)
+
+if selected_events == 0:
+    print("No events passed the selection / split. Nothing to plot.")
+    sys.exit(1)
+
+print(f"Processed {selected_events} selected events")
+
+
+# --------------------------------------------------------------------------------
+# plots: one feature per canvas
+# --------------------------------------------------------------------------------
+
+for feat in plot_feats:
+    edges = feature_edges[feat]
+    n_bins = len(edges) - 1
+    x_lo = edges[0]
+    x_hi = edges[-1]
+    x_title = PLOT_OPTS[feat]["tex"]
+
+    nominal = nominal_hists[feat]
+
+    coeff_truth = {}
+    coeff_pred = {}
+    coeff_values = []
+
+    nz = nominal != 0.0
+
+    for der in plot_derivatives:
+        ct = np.zeros_like(nominal, dtype=np.float64)
+        cp = np.zeros_like(nominal, dtype=np.float64)
+
+        if np.any(nz):
+            ct[nz] = truth_num_hists[feat][der][nz] / nominal[nz]
+            cp[nz] = pred_num_hists[feat][der][nz] / nominal[nz]
+
+        coeff_truth[der] = ct
+        coeff_pred[der] = cp
+
+        coeff_values.append(ct[np.isfinite(ct)])
+        coeff_values.append(cp[np.isfinite(cp)])
+
+    if coeff_values:
+        coeff_values = np.concatenate([v for v in coeff_values if len(v) > 0], axis=0) if any(len(v) > 0 for v in coeff_values) else np.array([0.0, 1.0])
+    else:
+        coeff_values = np.array([0.0, 1.0])
+
+    finite = np.isfinite(coeff_values)
+    if finite.any():
+        right_min = float(np.min(coeff_values[finite]))
+        right_max = float(np.max(coeff_values[finite]))
+    else:
+        right_min, right_max = -1.0, 1.0
+
+    if right_max <= right_min:
+        width = 1.0 if right_max == right_min else abs(right_max - right_min)
+        right_min -= 0.5 * width
+        right_max += 0.5 * width
+
+    #right_pad = 0.18 * (right_max - right_min)
+    #right_min -= right_pad
+    #right_max += right_pad
+
+    right_pad_lo = 0.18 * (right_max - right_min)
+    right_pad_hi = 0.28 * (right_max - right_min)
+    right_min -= right_pad_lo
+    right_max += right_pad_hi
+
+    left_max = float(np.max(nominal)) if len(nominal) else 0.0
+    if left_max <= 0.0:
+        left_max = 1.0
+
+    #left_max *= 1.25
+    left_max *= 1.35
+
+    canvas = ROOT.TCanvas(f"c_{feat}", feat, 900, 700)
+    canvas.SetLeftMargin(0.13)
+    canvas.SetRightMargin(0.14)
+    canvas.SetBottomMargin(0.13)
+    canvas.SetTopMargin(0.08)
+    canvas.SetTicks(1, 0)
+
+    frame = ROOT.TH1D(f"frame_{feat}", "", n_bins, edges.astype(np.float64))
+    frame.SetMinimum(0.0)
+    frame.SetMaximum(left_max)
+    frame.GetXaxis().SetTitle(x_title)
+    frame.GetYaxis().SetTitle("Number of events")
+    frame.GetXaxis().SetTitleSize(0.050)
+    frame.GetYaxis().SetTitleSize(0.050)
+    frame.GetXaxis().SetLabelSize(0.042)
+    frame.GetYaxis().SetLabelSize(0.042)
+    frame.GetYaxis().SetTitleOffset(1.20)
+    frame.Draw("axis")
+    frame.GetYaxis().SetTicks("-")
+
+    h_nominal = make_root_hist(f"h_nominal_{feat}", "", edges, nominal)
+    h_nominal.SetLineColor(ROOT.kGray + 2)
+    h_nominal.SetLineWidth(2)
+    h_nominal.SetFillColorAlpha(ROOT.kGray + 1, 0.35)
+    h_nominal.Draw("hist same")
+
+    drawn_objects = [frame, h_nominal]
+
+    for der in plot_derivatives:
+        y_truth_left = map_right_to_left(coeff_truth[der], right_min, right_max, left_max)
+        y_pred_left = map_right_to_left(coeff_pred[der], right_min, right_max, left_max)
+
+        h_truth = make_root_hist(f"h_truth_{feat}_{str(der)}", "", edges, y_truth_left)
+        h_pred = make_root_hist(f"h_pred_{feat}_{str(der)}", "", edges, y_pred_left)
+
+        color = root_colors[der]
+
+        h_truth.SetLineColor(color)
+        h_truth.SetLineStyle(2)
+        h_truth.SetLineWidth(3)
+        h_truth.SetMarkerStyle(0)
+
+        h_pred.SetLineColor(color)
+        h_pred.SetLineStyle(1)
+        h_pred.SetLineWidth(3)
+        h_pred.SetMarkerStyle(0)
+
+        h_truth.Draw("hist same")
+        h_pred.Draw("hist same")
+
+        drawn_objects.extend([h_truth, h_pred])
+
+    right_axis = ROOT.TGaxis(x_hi, 0.0, x_hi, left_max, right_min, right_max, 510, "+L")
+    right_axis.SetTitle("Polynomial coefficient")
+    right_axis.SetLabelFont(frame.GetYaxis().GetLabelFont())
+    right_axis.SetTitleFont(frame.GetYaxis().GetTitleFont())
+    right_axis.SetLabelSize(frame.GetYaxis().GetLabelSize())
+    right_axis.SetTitleSize(frame.GetYaxis().GetTitleSize())
+    right_axis.SetTitleOffset(1.15)
+    right_axis.SetLineWidth(1)
+    right_axis.Draw()
+
+    drawn_objects.append(right_axis)
+
+    canvas.RedrawAxis()
+    canvas.Modified()
+    canvas.Update()
+
+    file_stub = os.path.join(out_dir, feat)
+    canvas.SaveAs(file_stub + ".png")
+    canvas.SaveAs(file_stub + ".pdf")
+    canvas.Close()
+
+
+# --------------------------------------------------------------------------------
+# separate legend plot
+# --------------------------------------------------------------------------------
+
+legend_canvas = ROOT.TCanvas("c_legend", "legend", 1400, 900)
+legend_canvas.SetLeftMargin(0.03)
+legend_canvas.SetRightMargin(0.03)
+legend_canvas.SetBottomMargin(0.03)
+legend_canvas.SetTopMargin(0.10)
+
+legend_frame = ROOT.TH1D("legend_frame", "", 1, 0.0, 1.0)
+legend_frame.SetMinimum(0.0)
+legend_frame.SetMaximum(1.0)
+legend_frame.GetXaxis().SetLabelSize(0.0)
+legend_frame.GetYaxis().SetLabelSize(0.0)
+legend_frame.GetXaxis().SetTickLength(0.0)
+legend_frame.GetYaxis().SetTickLength(0.0)
+legend_frame.Draw("axis")
+
+legend_entries = 1 + 2 * len(plot_derivatives)
+if legend_entries > 30:
+    n_cols = 4
+elif legend_entries > 18:
+    n_cols = 3
+elif legend_entries > 8:
+    n_cols = 2
+else:
+    n_cols = 1
+
+legend = ROOT.TLegend(0.03, 0.08, 0.97, 0.90)
+legend.SetNColumns(n_cols)
+legend.SetBorderSize(0)
+legend.SetFillStyle(0)
+legend.SetTextSize(0.030)
+
+legend_objects = [legend_frame, legend]
+
+dummy_nominal = ROOT.TH1D("dummy_nominal", "", 1, 0.0, 1.0)
+dummy_nominal.SetLineColor(ROOT.kGray + 2)
+dummy_nominal.SetLineWidth(2)
+dummy_nominal.SetFillColorAlpha(ROOT.kGray + 1, 0.35)
+legend.AddEntry(dummy_nominal, "SM distribution", "lf")
+legend_objects.append(dummy_nominal)
+
+for der in plot_derivatives:
+    label = derivative_label(der)
+    color = root_colors[der]
+
+    dummy_truth = ROOT.TH1D(f"dummy_truth_{str(der)}", "", 1, 0.0, 1.0)
+    dummy_pred = ROOT.TH1D(f"dummy_pred_{str(der)}", "", 1, 0.0, 1.0)
+
+    dummy_truth.SetLineColor(color)
+    dummy_truth.SetLineStyle(2)
+    dummy_truth.SetLineWidth(3)
+
+    dummy_pred.SetLineColor(color)
+    dummy_pred.SetLineStyle(1)
+    dummy_pred.SetLineWidth(3)
+
+    legend.AddEntry(dummy_truth, f"truth  {label}", "l")
+    legend.AddEntry(dummy_pred,  f"BIT  {label}",   "l")
+
+    legend_objects.extend([dummy_truth, dummy_pred])
+
+legend.Draw()
+
+legend_canvas.Modified()
+legend_canvas.Update()
+
+legend_stub = os.path.join(out_dir, "legend")
+legend_canvas.SaveAs(legend_stub + ".png")
+legend_canvas.SaveAs(legend_stub + ".pdf")
+legend_canvas.Close()
+
+helpers.copyIndexPHP(out_dir)
+syncer.sync()
+print("Done.")
diff --git a/plot/bit/propaganda_plot_options.py b/plot/bit/propaganda_plot_options.py
new file mode 100644
index 0000000..31514eb
--- /dev/null
+++ b/plot/bit/propaganda_plot_options.py
@@ -0,0 +1,245 @@
+from math import pi
+
+plot_options = {
+    #"parton_Top_decayAngle_theta": { 'binning': [30,   0,    pi],   'tex': 'parton #theta(t_{t})',               'logY': False },
+    #"parton_Top_decayAngle_phi"  : { 'binning': [30,  -pi,   pi],   'tex': 'parton #phi(t_{t})',                 'logY': False },
+    "parton_Top_pt"              : { 'binning': [50,   0,  1500],   'tex': 'parton p_{T}(t_{t})',         'logY': True  },
+    "parton_Top_eta"             : { 'binning': [36, -3.6,   3.6],  'tex': 'parton #eta(t_{t})',          'logY': False },
+    "parton_Top_y"               : { 'binning': [26,  -2.6,  2.6],  'tex': 'parton y(t)'   ,              'logY': False },
+    "parton_Top_phi"             : { 'binning': [26,  -pi,  pi],    'tex': 'parton #phi(t)',              'logY': False },
+    "parton_Top_mass"            : { 'binning': [50,  135,  235],   'tex': 'parton M(t)',                 'logY': True  },
+
+    "parton_Top_f1_pt"           : { 'binning': [30,   0,   800],   'tex': 'parton p_{T}(f_{t}(t_{t}))',  'logY': True  },
+    "parton_Top_f1_eta"          : { 'binning': [30,  -3,     3],   'tex': 'parton #eta(f_{2}(t_{t}))',   'logY': False },
+    "parton_Top_f2_pt"           : { 'binning': [30,   0,   800],   'tex': 'parton p_{T}(f_{2} (t_{t}))', 'logY': True  },
+    "parton_Top_f2_eta"          : { 'binning': [30,  -3,     3],   'tex': 'parton #eta(f_{2}(t_{t}))',   'logY': False },
+    "parton_Top_b_pt"            : { 'binning': [50,   0,   800],   'tex': 'parton p_{T}(b (t_{t}))',     'logY': True  },
+    "parton_Top_b_eta"           : { 'binning': [30,  -3,     3],   'tex': 'parton #eta(b(t_{t}))',       'logY': False },
+    "parton_Top_W_pt"            : { 'binning': [30,   0,  1000],   'tex': 'parton p_{T}(W (t_{t}))',     'logY': True  },
+    "parton_Top_W_eta"           : { 'binning': [30,  -3,     3],   'tex': 'parton #eta(W(t_{t}))',       'logY': False },
+
+    #"parton_AntiTop_decayAngle_theta": { 'binning': [30,   0,    pi],   'tex': 'parton #theta(t_{#bar{t}})',        'logY': False },
+    #"parton_AntiTop_decayAngle_phi"  : { 'binning': [30,  -pi,   pi],   'tex': 'parton #phi(t_{#bar{t}})',          'logY': False },
+    "parton_AntiTop_pt"              : { 'binning': [50,   0,  1500],   'tex': 'parton p_{T}(t_{#bar{t}})',         'logY': True  },
+    "parton_AntiTop_eta"             : { 'binning': [36, -3.6,  3.6],   'tex': 'parton #eta(t_{#bar{t}})',          'logY': False },
+    "parton_AntiTop_y"               : { 'binning': [26,  -2.6, 2.6],   'tex': 'parton y(#bar{t})'   ,              'logY': False },
+    "parton_AntiTop_phi"             : { 'binning': [26,  -pi,  pi],    'tex': 'parton #phi(#bar{t})',              'logY': False },
+    "parton_AntiTop_mass"            : { 'binning': [50,  135,  235],   'tex': 'parton M(#bar{t})',                 'logY': True  },
+    "parton_AntiTop_f1_pt"           : { 'binning': [30,   0,   800],   'tex': 'parton p_{T}(f_{1}(t_{#bar{t}}))',  'logY': True  },
+    "parton_AntiTop_f1_eta"          : { 'binning': [30,  -3,     3],   'tex': 'parton #eta(f_{1}(t_{#bar{t}}))',   'logY': False },
+    "parton_AntiTop_f2_pt"           : { 'binning': [30,   0,   800],   'tex': 'parton p_{T}(f_{#bar{t}} (t_{#bar{t}}))','logY': True  },
+    "parton_AntiTop_f2_eta"          : { 'binning': [30,  -3,     3],   'tex': 'parton #eta(f_{#bar{t}}(t_{#bar{t}}))',  'logY': False },
+    "parton_AntiTop_b_pt"            : { 'binning': [50,   0,   800],   'tex': 'parton p_{T}(b (t_{#bar{t}}))',     'logY': True  },
+    "parton_AntiTop_b_eta"           : { 'binning': [30,  -3,     3],   'tex': 'parton #eta(b(t_{#bar{t}}))',       'logY': False },
+    "parton_AntiTop_W_pt"            : { 'binning': [30,   0,  1000],   'tex': 'parton p_{T}(W (t_{#bar{t}}))',     'logY': True  },
+    "parton_AntiTop_W_eta"           : { 'binning': [30,  -3,     3],   'tex': 'parton #eta(W(t_{#bar{t}}))',       'logY': False },
+
+    "parton_ttbar_pt"             : { 'binning': [50,   0,  1000],   'tex': 'parton p_{T}(t#bar{t})',       'logY': True  },
+    "parton_ttbar_mass"           : { 'binning': [50,   0,  2000],   'tex': 'parton M(t#bar{t})',           'logY': True  },
+    "parton_ttbar_eta"            : { 'binning': [30,  -3,     3],   'tex': 'parton #eta(t#bar{t})',        'logY': False },
+    "parton_ttbar_y"              : { 'binning': [30,  -3,     3],   'tex': 'parton y(t#bar{t})',           'logY': False },
+    "parton_ttbar_beta_plus"      : { 'binning': [50,   0,     1],   'tex': 'parton #beta^{+}',             'logY': False },
+    "parton_ttbar_dEta"           : { 'binning': [30,  -3,     3],   'tex': 'parton #Delta#eta(t#bar{t})',  'logY': False },
+    "parton_ttbar_dAbsEta"        : { 'binning': [30,  -3,     3],   'tex': 'parton #Delta|#eta|(t#bar{t})','logY': False },
+
+    "parton_cosThetaPlus_n"       : { 'binning': [30,  -1,     1],   'tex': 'parton cos#theta^{+}_{n}',    'logY': False },
+    "parton_cosThetaMinus_n"      : { 'binning': [30,  -1,     1],   'tex': 'parton cos#theta^{-}_{n}',    'logY': False },
+    "parton_cosThetaPlus_r"       : { 'binning': [30,  -1,     1],   'tex': 'parton cos#theta^{+}_{r}',    'logY': False },
+    "parton_cosThetaMinus_r"      : { 'binning': [30,  -1,     1],   'tex': 'parton cos#theta^{-}_{r}',    'logY': False },
+    "parton_cosThetaPlus_k"       : { 'binning': [30,  -1,     1],   'tex': 'parton cos#theta^{+}_{k}',    'logY': False },
+    "parton_cosThetaMinus_k"      : { 'binning': [30,  -1,     1],   'tex': 'parton cos#theta^{-}_{k}',    'logY': False },
+    "parton_cosThetaPlus_r_star"  : { 'binning': [30,  -1,     1],   'tex': 'parton cos#theta^{+*}_{n}',   'logY': False },
+    "parton_cosThetaMinus_r_star" : { 'binning': [30,  -1,     1],   'tex': 'parton cos#theta^{-*}_{n}',   'logY': False },
+    "parton_cosThetaPlus_k_star"  : { 'binning': [30,  -1,     1],   'tex': 'parton cos#theta^{+*}_{k}',   'logY': False },
+    "parton_cosThetaMinus_k_star" : { 'binning': [30,  -1,     1],   'tex': 'parton cos#theta^{-*}_{k}',   'logY': False },
+    "parton_xi_nn"                : { 'binning': [30,  -1,     1],   'tex': 'parton #xi_{nn}',             'logY': False },
+    "parton_xi_rr"                : { 'binning': [30,  -1,     1],   'tex': 'parton #xi_{rr}',             'logY': False },
+    "parton_xi_kk"                : { 'binning': [30,  -1,     1],   'tex': 'parton #xi_{kk}',             'logY': False },
+    "parton_xi_nr_plus"           : { 'binning': [30,  -1,     1],   'tex': 'parton #xi_{nr}^{+}',         'logY': False },
+    "parton_xi_nr_minus"          : { 'binning': [30,  -1,     1],   'tex': 'parton #xi_{nr}^{-}',         'logY': False },
+    "parton_xi_rk_plus"           : { 'binning': [30,  -1,     1],   'tex': 'parton #xi_{rk}^{+}',         'logY': False },
+    "parton_xi_rk_minus"          : { 'binning': [30,  -1,     1],   'tex': 'parton #xi_{rk}^{-}',         'logY': False },
+    "parton_xi_nk_plus"           : { 'binning': [30,  -1,     1],   'tex': 'parton #xi_{nk}^{+}',         'logY': False },
+    "parton_xi_nk_minus"          : { 'binning': [30,  -1,     1],   'tex': 'parton #xi_{nk}^{-}',         'logY': False },
+
+    "parton_xi_r_star_k"          : { 'binning': [30,  -1,     1],   'tex': 'parton #xi_{r^{*}k}',         'logY': False },
+    "parton_xi_k_r_star"          : { 'binning': [30,  -1,     1],   'tex': 'parton #xi_{kr^{*}}',         'logY': False },
+    "parton_xi_kk_star"           : { 'binning': [30,  -1,     1],   'tex': 'parton #xi_{kk^{*}}',         'logY': False },
+
+    "parton_cos_phi"              : { 'binning': [30,  -1,     1],   'tex': 'parton cos(#phi)',            'logY': False },
+    "parton_c_hel"                : { 'binning': [30,  -1,     1],   'tex': 'parton c_{hel}',              'logY': False },
+    "parton_c_han"                : { 'binning': [30,  -1,     1],   'tex': 'parton c_{han}',              'logY': False },
+    "parton_cos_phi_lab"          : { 'binning': [30,  -1,     1],   'tex': 'parton cos(#phi lab)',        'logY': False },
+    "parton_abs_delta_phi_ll_lab" : { 'binning': [30,   0,    pi],   'tex': 'parton |#Delta(#phi(l,l))|',  'logY': False },
+
+    "recoBj01_pt"                 : { 'binning': [30,   0,  1500],   'tex': 'p_{T}(bb)',                   'logY': True  },
+    "recoBj01_mass"               : { 'binning': [30,   0,  1500],   'tex': 'M(bb)',                       'logY': True  },
+    "nBTag"                       : { 'binning': [ 4,   0,     4],   'tex': 'N_{b}',                       'logY': False },
+    "nBJet"                       : { 'binning': [ 4,   0,     4],   'tex': 'N_{b}',                       'logY': False },
+    "lep0_pt"                     : { 'binning': [26,  20,   280],   'tex': 'p_{T}(l_{1})',                'logY': True  },
+    "lep0_eta"                    : { 'binning': [26,  -2.6,  2.6],  'tex': '#eta(l_{1})',                 'logY': False },
+    "lep0_phi"                    : { 'binning': [26,  -pi,  pi],    'tex': '#phi(l_{1})',                 'logY': False },
+    "lep0_charge"                 : { 'binning': [3,   -1,     1],   'tex': 'charge(l_{1})',               'logY': False },
+    "lep1_pt"                     : { 'binning': [20,  20,   220],   'tex': 'p_{T}(l_{2})',                'logY': True  },
+    "lep1_eta"                    : { 'binning': [26,  -2.6,  2.6],  'tex': '#eta(l_{2})',                 'logY': False },
+    "lep1_phi"                    : { 'binning': [26,  -pi,  pi],    'tex': '#phi(l_{2})',                 'logY': False },
+    "lep1_charge"                 : { 'binning': [3,   -1,     1],   'tex': 'charge(l_{2})',               'logY': False },
+    "dilep_pt"                    : { 'binning': [30,   0,   300],   'tex': 'p_{T}(ll)',                   'logY': True  },
+    "dilep_eta"                   : { 'binning': [42,  -4.2, 4.2],   'tex': '#eta(ll)',                    'logY': False },
+    "dilep_phi"                   : { 'binning': [26,  -pi, pi],     'tex': '#phi(ll)',                    'logY': False },
+    "dilep_mass"                  : { 'binning': [25,  20,  520],   'tex': 'M(ll)',                       'logY': True  },
+    "recoLep0_eta"                : { 'binning': [26,  -2.6,  2.6],  'tex': '#eta(l_{1})',                 'logY': False },
+    "recoLep1_pt"                 : { 'binning': [21,  20,   440],   'tex': 'p_{T}(l_{2})',                'logY': True  },
+    "recoLep1_eta"                : { 'binning': [26,  -2.6,  2.6],  'tex': '#eta(l_{2})',                 'logY': False },
+    "recoLepPos_pt"               : { 'binning': [21,  20,   440],   'tex': 'p_{T}(l^{+})',                'logY': True  },
+    "recoLepPos_eta"              : { 'binning': [26,  -2.6,  2.6],  'tex': '#eta(l^{+})',                 'logY': False },
+    "recoLepNeg_pt"               : { 'binning': [21,  20,   440],   'tex': 'p_{T}(l^{-})',                'logY': True  },
+    "recoLepNeg_eta"              : { 'binning': [26,  -2.6,  2.6],  'tex': '#eta(l^{-})',                 'logY': False },
+    "recoLep01_pt"                : { 'binning': [21,   0,   440],   'tex': 'p_{T}(ll)',                   'logY': True  },
+    "recoLep01_mass"              : { 'binning': [20,  20,  1020],   'tex': 'M(ll)',                       'logY': True  },
+    "recoLep_dPhi"                : { 'binning': [30,  -pi,   pi],   'tex': '#Delta#phi(ll)',              'logY': False },
+    "recoLep_dEta"                : { 'binning': [26,  -2.6,  2.6],  'tex': '#Delta#eta(ll)',              'logY': False },
+    "recoLep_dAbsEta"             : { 'binning': [26,  -2.6,  2.6],  'tex': '#Delta|#eta|(ll)',            'logY': False },
+    "dilep_dEta"                  : { 'binning': [42,  -4.2,  4.2],  'tex': '#Delta#eta(ll)',              'logY': False },
+    "dilep_dAbsEta"               : { 'binning': [26,  -2.6,  2.6],  'tex': '#Delta|#eta|(ll)',            'logY': False },
+
+    #"tr_top_decayAngle_theta"     : { 'binning': [30,   0,    pi],   'tex': '#theta(t_{1})',               'logY': False },
+    #"tr_top_decayAngle_phi"       : { 'binning': [30,  -pi,   pi],   'tex': '#phi(t_{1})',                 'logY': False },
+    "tr_top_pt"                   : { 'binning': [30,   0,   1200],   'tex': 'p_{T}(t_{1})',                'logY': True  },
+    "tr_top_eta"                  : { 'binning': [26,  -2.6,  2.6],   'tex': '#eta(t_{1})',                 'logY': False },
+    #"tr_top_f1_pt"                : { 'binning': [30,   0,   800],   'tex': 'p_{T}(f_{1}(t_{1}))',         'logY': True  },
+    #"tr_top_f1_eta"               : { 'binning': [30,  -3,     3],   'tex': '#eta(f_{2}(t_{1}))',          'logY': False },
+    #"tr_top_f2_pt"                : { 'binning': [30,   0,   800],   'tex': 'p_{T}(f_{2} (t_{1}))',        'logY': True  },
+    #"tr_top_f2_eta"               : { 'binning': [30,  -3,     3],   'tex': '#eta(f_{2}(t_{1}))',          'logY': False },
+    #"tr_top_b_pt"                 : { 'binning': [50,   0,   800],   'tex': 'p_{T}(b (t_{1}))',            'logY': True  },
+    #"tr_top_b_eta"                : { 'binning': [30,  -3,     3],   'tex': '#eta(b(t_{1}))',              'logY': False },
+    #"tr_top_W_pt"                 : { 'binning': [30,   0,  1000],   'tex': 'p_{T}(W (t_{1}))',            'logY': True  },
+    #"tr_top_W_eta"                : { 'binning': [30,  -3,     3],   'tex': '#eta(W(t_{1}))',              'logY': False },
+
+    #"tr_topBar_decayAngle_theta"  : { 'binning': [30,   0,    pi],   'tex': '#theta(t_{2})',               'logY': False },
+    #"tr_topBar_decayAngle_phi"    : { 'binning': [30,  -pi,   pi],   'tex': '#phi(t_{2})',                 'logY': False },
+    "tr_topBar_pt"                : { 'binning': [20,   0,   800],   'tex': 'p_{T}(t_{2})',                'logY': True  },
+    "tr_topBar_eta"               : { 'binning': [26,  -2.6,  2.6],  'tex': '#eta(t_{2})',                 'logY': False },
+    #"tr_topBar_f1_pt"             : { 'binning': [30,   0,   800],   'tex': 'p_{T}(f_{1}(t_{2}))',         'logY': True  },
+    #"tr_topBar_f1_eta"            : { 'binning': [30,  -3,     3],   'tex': '#eta(f_{1}(t_{2}))',          'logY': False },
+    #"tr_topBar_f2_pt"             : { 'binning': [30,   0,   800],   'tex': 'p_{T}(f_{2} (t_{2}))',        'logY': True  },
+    #"tr_topBar_f2_eta"            : { 'binning': [30,  -3,     3],   'tex': '#eta(f_{2}(t_{2}))',          'logY': False },
+    #"tr_topBar_b_pt"              : { 'binning': [50,   0,   800],   'tex': 'p_{T}(b (t_{2}))',            'logY': True  },
+    #"tr_topBar_b_eta"             : { 'binning': [30,  -3,     3],   'tex': '#eta(b(t_{2}))',              'logY': False },
+    #"tr_topBar_W_pt"              : { 'binning': [30,   0,  1000],   'tex': 'p_{T}(W (t_{2}))',            'logY': True  },
+    #"tr_topBar_W_eta"             : { 'binning': [30,  -3,     3],   'tex': '#eta(W(t_{2}))',              'logY': False },
+
+    "tr_Top_pt"                   : { 'binning': [30,   0,   600],  'tex': 'p_{T}(t)',                    'logY': True  },
+    "tr_Top_eta"                  : { 'binning': [36,  -3.6,  3.6],  'tex': '#eta(t)',                     'logY': False },
+    "tr_Top_y"                    : { 'binning': [24,  -2.4,  2.4],  'tex': 'y(t)'   ,                     'logY': False },
+    "tr_Top_phi"                  : { 'binning': [26,  -pi,  pi],    'tex': '#phi(t)',                     'logY': False },
+    "tr_Top_mass"                 : { 'binning': [50,  135,  235],   'tex': 'M(t)',                        'logY': True  },
+
+    "tr_AntiTop_pt"               : { 'binning': [30,   0,    600],   'tex': 'p_{T}(#bar{t})',              'logY': True  },
+    "tr_AntiTop_eta"              : { 'binning': [36,  -3.6,  3.6],  'tex': '#eta(#bar{t})',               'logY': False },
+    "tr_AntiTop_y"                : { 'binning': [26,  -2.6,  2.6],  'tex': 'y(#bar{t})',                  'logY': False },
+    "tr_AntiTop_phi"              : { 'binning': [26,  -pi,  pi],    'tex': '#phi(#bar{t})',               'logY': False },
+    "tr_AntiTop_mass"             : { 'binning': [50,  135,  235],   'tex': 'M(#bar{t})',                  'logY': True  },
+
+    "tr_Wp_pt"                    : { 'binning': [30,   0,   1200],  'tex': 'p_{T}(W^{+})',                'logY': True  },
+    "tr_Wp_eta"                   : { 'binning': [26,  -2.6,  2.6],  'tex': '#eta(W^{+})',                 'logY': False },
+    "tr_Wp_phi"                   : { 'binning': [26,  -pi,  pi],    'tex': '#phi(W^{+})',                 'logY': False },
+    "tr_Wp_mass"                  : { 'binning': [50,  35,  135],    'tex': 'M(W^{+})',                    'logY': True  },
+
+    "tr_Wm_pt"                    : { 'binning': [30,   0,  1200],   'tex': 'p_{T}(W^{-})',                'logY': True  },
+    "tr_Wm_eta"                   : { 'binning': [26,  -2.6,  2.6],  'tex': '#eta(W^{-})',                 'logY': False },
+    "tr_Wm_phi"                   : { 'binning': [26,  -pi,  pi],    'tex': '#phi(W^{-})',                 'logY': False },
+    "tr_Wm_mass"                  : { 'binning': [50,  35,  135],    'tex': 'M(W^{-})',                    'logY': True  },
+
+    "tr_b_pt"                     : { 'binning': [30,   0,   1200],  'tex': 'p_{T}(b)',                    'logY': True  },
+    "tr_b_eta"                    : { 'binning': [26,  -2.6,  2.6],  'tex': '#eta(b)',                     'logY': False },
+    "tr_b_phi"                    : { 'binning': [26,  -pi,  pi],    'tex': '#phi(b)',                     'logY': False },
+    "tr_b_mass"                   : { 'binning': [50,   0,    20],   'tex': 'M(b)',                        'logY': True  },
+
+    "tr_antib_pt"                 : { 'binning': [30,   0,  1200],   'tex': 'p_{T}(#bar{b})',              'logY': True  },
+    "tr_antib_eta"                : { 'binning': [26,  -2.6, 2.6],   'tex': '#eta(#bar{b})',               'logY': False },
+    "tr_antib_phi"                : { 'binning': [26,  -pi,   pi],   'tex': '#phi(#bar{b})',               'logY': False },
+    "tr_antib_mass"               : { 'binning': [50,   0,    20],   'tex': 'M(#bar{b})',                  'logY': True  },
+
+    "tr_lep_pt"                   : { 'binning': [30,   0,   1200],  'tex': 'p_{T}(l)',                    'logY': True  },
+    "tr_lep_eta"                  : { 'binning': [26,  -2.6,  2.6],  'tex': '#eta(l)',                     'logY': False },
+    "tr_lep_phi"                  : { 'binning': [26,  -pi,  pi],    'tex': '#phi(l)',                     'logY': False },
+    "tr_lep_mass"                 : { 'binning': [50,   0,     1],   'tex': 'M(l)',                        'logY': True  },
+
+    "tr_antilep_pt"               : { 'binning': [30,   0,  1200],   'tex': 'p_{T}(#bar{l})',              'logY': True  },
+    "tr_antilep_eta"              : { 'binning': [26,  -2.6, 2.6],   'tex': '#eta(#bar{l})',               'logY': False },
+    "tr_antilep_phi"              : { 'binning': [26,  -pi,   pi],   'tex': '#phi(#bar{l})',               'logY': False },
+    "tr_antilep_mass"             : { 'binning': [50,   0,     1],   'tex': 'M(#bar{l})',                  'logY': True  },
+
+    "tr_nu_pt"                    : { 'binning': [30,   0,   1200],  'tex': 'p_{T}(#nu)',                  'logY': True  },
+    "tr_nu_eta"                   : { 'binning': [26,  -2.6,  2.6],  'tex': '#eta(#nu)',                   'logY': False },
+    "tr_nu_phi"                   : { 'binning': [26,  -pi,  pi],    'tex': '#phi(#nu)',                   'logY': False },
+    "tr_nu_mass"                  : { 'binning': [50,   0,   100],   'tex': 'M(#nu)',                      'logY': True  },
+
+    "tr_antinu_pt"                : { 'binning': [30,   0,  1200],   'tex': 'p_{T}(#bar{#nu})',            'logY': True  },
+    "tr_antinu_eta"               : { 'binning': [26,  -2.6, 2.6],   'tex': '#eta(#bar{#nu})',             'logY': False },
+    "tr_antinu_phi"               : { 'binning': [26,  -pi,   pi],   'tex': '#phi(#bar{#nu})',             'logY': False },
+    "tr_antinu_mass"              : { 'binning': [50,   0,   100],   'tex': 'M(#bar{#nu})',                'logY': True  },
+
+    "tr_ttbar_pt"                 : { 'binning': [30,   0,  600],   'tex': 'p_{T}(t#bar{t})',             'logY': True  },
+    "tr_ttbar_mass"               : { 'binning': [29, 350,  1800],   'tex': 'M(t#bar{t})',                 'logY': True  },
+    "tr_ttbar_eta"                : { 'binning': [26,  -2.6,  2.6],  'tex': '#eta(t#bar{t})',              'logY': False },
+    "tr_ttbar_phi"                : { 'binning': [26,  -pi,  pi],    'tex': '#phi(t#bar{t})',              'logY': False },
+    "tr_ttbar_y"                  : { 'binning': [22,  -2.2,  2.2],  'tex': 'y(t#bar{t})',                 'logY': False },
+    "tr_ttbar_beta_plus"          : { 'binning': [50,    0,     1],  'tex': '#beta^{+}',                   'logY': False },
+    "tr_ttbar_dEta"               : { 'binning': [36,  -3.6,  3.6],  'tex': '#Delta#eta(t#bar{t})',        'logY': False },
+    "tr_ttbar_dAbsEta"            : { 'binning': [26,  -2.6,  2.6],  'tex': '#Delta|#eta|(t#bar{t})',      'logY': False },
+
+    "tr_cosThetaPlus_n"           : { 'binning': [30,  -1,     1],   'tex': 'cos#theta^{+}_{n}',           'logY': False },
+    "tr_cosThetaMinus_n"          : { 'binning': [30,  -1,     1],   'tex': 'cos#theta^{-}_{n}',           'logY': False },
+    "tr_cosThetaPlus_r"           : { 'binning': [30,  -1,     1],   'tex': 'cos#theta^{+}_{r}',           'logY': False },
+    "tr_cosThetaMinus_r"          : { 'binning': [30,  -1,     1],   'tex': 'cos#theta^{-}_{r}',           'logY': False },
+    "tr_cosThetaPlus_k"           : { 'binning': [30,  -1,     1],   'tex': 'cos#theta^{+}_{k}',           'logY': False },
+    "tr_cosThetaMinus_k"          : { 'binning': [30,  -1,     1],   'tex': 'cos#theta^{-}_{k}',           'logY': False },
+    "tr_cosThetaPlus_r_star"      : { 'binning': [30,  -1,     1],   'tex': 'cos#theta^{+*}_{n}',          'logY': False },
+    "tr_cosThetaMinus_r_star"     : { 'binning': [30,  -1,     1],   'tex': 'cos#theta^{-*}_{n}',          'logY': False },
+    "tr_cosThetaPlus_k_star"      : { 'binning': [30,  -1,     1],   'tex': 'cos#theta^{+*}_{k}',          'logY': False },
+    "tr_cosThetaMinus_k_star"     : { 'binning': [30,  -1,     1],   'tex': 'cos#theta^{-*}_{k}',          'logY': False },
+    "tr_xi_nn"                    : { 'binning': [30,  -1,     1],   'tex': '#xi_{nn}',                    'logY': False },
+    "tr_xi_rr"                    : { 'binning': [30,  -1,     1],   'tex': '#xi_{rr}',                    'logY': False },
+    "tr_xi_kk"                    : { 'binning': [30,  -1,     1],   'tex': '#xi_{kk}',                    'logY': False },
+    "tr_xi_nr_plus"               : { 'binning': [30,  -1,     1],   'tex': '#xi_{nr}^{+}',                'logY': False },
+    "tr_xi_nr_minus"              : { 'binning': [30,  -1,     1],   'tex': '#xi_{nr}^{-}',                'logY': False },
+    "tr_xi_rk_plus"               : { 'binning': [30,  -1,     1],   'tex': '#xi_{rk}^{+}',                'logY': False },
+    "tr_xi_rk_minus"              : { 'binning': [30,  -1,     1],   'tex': '#xi_{rk}^{-}',                'logY': False },
+    "tr_xi_nk_plus"               : { 'binning': [30,  -1,     1],   'tex': '#xi_{nk}^{+}',                'logY': False },
+    "tr_xi_nk_minus"              : { 'binning': [30,  -1,     1],   'tex': '#xi_{nk}^{-}',                'logY': False },
+
+    "tr_xi_r_star_k"              : { 'binning': [30,  -1,     1],   'tex': '#xi_{r^{*}k}',                'logY': False },
+    "tr_xi_k_r_star"              : { 'binning': [30,  -1,     1],   'tex': '#xi_{kr^{*}}',                'logY': False },
+    "tr_xi_kk_star"               : { 'binning': [30,  -1,     1],   'tex': '#xi_{kk^{*}}',                'logY': False },
+
+    "tr_cos_phi"                  : { 'binning': [30,  -1,     1],   'tex': 'cos(#phi)',                   'logY': False },
+    "tr_c_hel"                    : { 'binning': [30,  -1,     1],   'tex': 'c_{hel}',                     'logY': False },
+    "tr_c_han"                    : { 'binning': [30,  -1,     1],   'tex': 'c_{han}',                     'logY': False },
+    "tr_cos_phi_lab"              : { 'binning': [30,  -1,     1],   'tex': 'cos(#phi lab)',               'logY': False },
+    "tr_abs_delta_phi_ll_lab"     : { 'binning': [30,   0,    pi],   'tex': '|#Delta(#phi(l,l))|',         'logY': False },
+
+    "nSelJet"                     : { 'binning': [ 8,   2,    10],   'tex': 'N_{jet}',                     'logY': False },
+    "nrecoJet"                    : { 'binning': [ 8,   2,    10],   'tex': 'N_{jet}',                     'logY': False },
+    "nrecoLep"                    : { 'binning': [ 4,   0,     4],   'tex': 'N_{lep}',                     'logY': False },
+    "jet0_pt"                     : { 'binning': [30,   0,  1500],   'tex': 'p_{T}(jet_{0})',              'logY': True  },
+    "jet1_pt"                     : { 'binning': [30,   0,   800],   'tex': 'p_{T}(jet_{1})',              'logY': True  },
+    "jet2_pt"                     : { 'binning': [30,   0,   800],   'tex': 'p_{T}(jet_{2})',              'logY': True  },
+    "jet3_pt"                     : { 'binning': [30,   0,   500],   'tex': 'p_{T}(jet_{3})',              'logY': True  },
+    "jet0_eta"                    : { 'binning': [26, -2.6,  2.6],   'tex': '#eta(jet_{0})',               'logY': True  },
+    "jet1_eta"                    : { 'binning': [26, -2.6,  2.6],   'tex': '#eta(jet_{1})',               'logY': True  },
+    "jet2_eta"                    : { 'binning': [26, -2.6,  2.6],   'tex': '#eta(jet_{2})',               'logY': True  },
+    "jet3_eta"                    : { 'binning': [26, -2.6,  2.6],   'tex': '#eta(jet_{3})',               'logY': True  },
+
+    "ht"                          : { 'binning': [30,   0,  2500],   'tex': 'H_{T}(GeV)',                  'logY': True  },
+    "MET_pt"                      : { 'binning': [30,   0,   500],   'tex': 'MET(GeV)',                    'logY': True  },
+    "MET_phi"                     : { 'binning': [26,  -pi,   pi],   'tex': '#phi(MET)',                   'logY': False },
+
+    "Generator_x1"                : { 'binning': [30,   0,     1],   'tex': 'x_{1,Bjorken}',               'logY': False },
+    "Generator_x2"                : { 'binning': [30,   0,     1],   'tex': 'x_{2,Bjorken}',               'logY': False },
+    "Generator_id1"               : { 'binning': [26,  -5,    21],   'tex': 'PDGID(1)',                    'logY': False },
+    "Generator_id2"               : { 'binning': [26,  -5,    21],   'tex': 'PDGID(2)',                    'logY': False },
+
+    "x"                           : { 'binning': [20,   0,     1],   'tex': 'x',                           'logY': False },
+}

From 42d9f264b5c666fe71c3e8741cb207327e6db26e Mon Sep 17 00:00:00 2001
From: Ricardo Barrue <ricardo.barrue@cern.ch>
Date: Thu, 23 Apr 2026 10:19:09 +0200
Subject: [PATCH 08/17] Postfit plots from binned config + unbinned fit result

---
 plot/postfitsys/binned_fromfit.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/plot/postfitsys/binned_fromfit.py b/plot/postfitsys/binned_fromfit.py
index 3998e58..21ba026 100644
--- a/plot/postfitsys/binned_fromfit.py
+++ b/plot/postfitsys/binned_fromfit.py
@@ -186,14 +186,12 @@ def evaluate_class(cls, h_base):
     x_title_default = "bin"
     logY_default = False
 
-print(f"{default_binning=}")
-print(f"{var_name=}, {var_edges_default=}")
-
 base = os.path.splitext(os.path.basename(config_path))[0]
+base_fit_result = os.path.splitext(os.path.basename(args.fit_result))[0]
 version = str(cfg.get("version", "v0"))
 suffix = "_rotate" if rotated else ""
 if args.outdir is None:
-    outdir = os.path.join(user.plot_directory, "binned_postfit_fromfit", base, f"{version}{suffix}")
+    outdir = os.path.join(user.plot_directory, "binned_postfit_fromfit", base, f"{version}{suffix}",f"from_{base_fit_result}")
 else:
     outdir = args.outdir
 os.makedirs(outdir, exist_ok=True)
@@ -414,7 +412,6 @@ def evaluate_class(cls, h_base):
             )
 
         for ib, value in enumerate(data_unrolled, start=1):
-            print(f"data histogram: {ib=}, {value=}; {h_total.GetBinContent(ib)=}")
             h_data.SetBinContent(ib, float(value))
         
     h_data.SetDirectory(0)
@@ -437,7 +434,7 @@ def evaluate_class(cls, h_base):
         ey  = h_data.GetBinError(ib)   # stat-only = sqrt(y) \  
 
         if nom > 0.0:
-            rel = ey/nom
+            rel = max(abs(y+ey-nom), abs(y-ey-nom))/nom
             h_ratio_data.SetBinContent(ib, y / nom)
             h_ratio_data.SetBinError(ib, ey / nom)
             max_dev_data = max(max_dev_data, rel)
@@ -588,9 +585,12 @@ def evaluate_class(cls, h_base):
             h_ratio_up.SetBinContent(ib, 1.0)
             h_ratio_down.SetBinContent(ib, 1.0)
 
+    # if all data points fall within MC uncertainty band
+    # range is defined by that
+    # else, range is defined by max deviation of data
+    # so that all data points are visible
     if is_data_fit:
-        max_dev = max_dev_data
-        print(f"{max_dev_data=}")    
+        max_dev = max(max_dev,max_dev_data)
 
     if max_dev <= 0.0:
         r_min, r_max = 0.9, 1.1

From 2d55722af5af1563eb2749b217c27bfa5e6a2a92 Mon Sep 17 00:00:00 2001
From: Ricardo Barrue <ricardo.barrue@cern.ch>
Date: Thu, 23 Apr 2026 10:20:13 +0200
Subject: [PATCH 09/17] Fit comparisons for subsets of parameters

---
 plot/postfitsys/compare_fits.py | 145 +++++++++++++++++---------------
 1 file changed, 79 insertions(+), 66 deletions(-)

diff --git a/plot/postfitsys/compare_fits.py b/plot/postfitsys/compare_fits.py
index 2cb89c7..7db303f 100644
--- a/plot/postfitsys/compare_fits.py
+++ b/plot/postfitsys/compare_fits.py
@@ -2,11 +2,12 @@
 import argparse
 import matplotlib.pyplot as plt
 import numpy as np
-from typing import List, Dict, Tuple
+from typing import List, Dict, Tuple, Optional
 import os
 
 import common.syncer as syncer
 import common.user as user
+import common.helpers as helpers
 
 
 def load_fit_results(json_path: str) -> Tuple[str, List[Dict]]:
@@ -25,9 +26,9 @@ def load_fit_results(json_path: str) -> Tuple[str, List[Dict]]:
 def create_comparison_plot(
     fit_files: List[str],
     output_dir: str,
-    blind_params: List[str] = None
+    blind_params: Optional[List[str]] = None
 ) -> None:
-    """Create comparison plot of fit parameters across multiple fits."""
+    """Create split comparison plots for CMS and non-CMS fit parameters."""
     
     blind_params = blind_params or []
     
@@ -35,71 +36,79 @@ def create_comparison_plot(
     for fit_file in fit_files:
         version, params = load_fit_results(fit_file)
         fit_data.append((version, params))
-    
-    num_fits = len(fit_data)
-    param_names = [p['name'] for p in fit_data[0][1]]
-    num_params = len(param_names)
-    
-    fig, ax = plt.subplots(figsize=(12, max(10, num_params * 0.3)))
-    
-    y_positions = np.arange(num_params)
-    bar_height = 0.8 / num_fits
-    # from https://matplotlib.org/stable/gallery/color/color_sequences.html
-    colors = plt.color_sequences['tab10']
-    
-    for fit_idx, (version, params) in enumerate(fit_data):
-        values = []
-        errors = []
-        labels_display = []
-        
-        for param in params:
-            param_name = param['name']
-            
-            if param_name in blind_params:
-                values.append(0)
-                errors.append(0)
-                labels_display.append('x')
-            else:
-                values.append(param['value'])
-                errors.append(param['error'])
-                labels_display.append(f"{param['value']:.2f}")
-        
-        y_offset = y_positions + (num_fits - 1) * bar_height / 2 - fit_idx * bar_height
-        
-        bars = ax.barh(
-            y_offset,
-            values,
-            bar_height,
-            xerr=errors,
-            label=version,
-            color=colors[fit_idx],
-            ecolor=colors[fit_idx],
-            alpha=0.8,
-            capsize=3
-        )
-    
-    # Add horizontal lines between parameters
-    for i in range(num_params - 1):
-        ax.axhline(y=i + 0.5, color='gray', linestyle='--', linewidth=0.5, alpha=0.3)
-    
-    ax.set_yticks(y_positions)
-    ax.set_yticklabels(param_names, fontsize=9)
-    ax.set_xlabel('Parameter value', fontsize=11)
-    ax.legend(loc='upper right', fontsize=10)
-    ax.grid(axis='x', alpha=0.3)
-    ax.set_xlim(-5.0,5.0)
-    ax.axvline(x=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5)
-    
-    plt.tight_layout()
-    
+
     os.makedirs(output_dir, exist_ok=True)
-    
-    plt.savefig(output_dir + '/fit_comparison.png', dpi=150, bbox_inches='tight')
-    plt.savefig(output_dir + '/fit_comparison.pdf', bbox_inches='tight')
-    plt.close(fig)
 
-if __name__ == '__main__':
-    
+    num_fits = len(fit_data)
+    all_param_names = [p['name'] for p in fit_data[0][1]]
+    cms_param_names = [param_name for param_name in all_param_names if 'CMS' in param_name]
+    other_param_names = [param_name for param_name in all_param_names if 'CMS' not in param_name]
+
+    def save_plot_for_parameters(param_names: List[str], output_basename: str) -> None:
+        """Create and save a comparison plot for a specific parameter subset."""
+        if not param_names:
+            return
+
+        num_params = len(param_names)
+        fig, ax = plt.subplots(figsize=(12, max(10, num_params * 0.3)))
+
+        y_positions = np.arange(num_params)
+        bar_height = 0.8 / num_fits
+        # from https://matplotlib.org/stable/gallery/color/color_sequences.html
+        colors = plt.color_sequences['tab10']
+
+        for fit_idx, (version, params) in enumerate(fit_data):
+            params_by_name = {param['name']: param for param in params}
+            values = []
+            errors = []
+
+            for param_name in param_names:
+                param = params_by_name[param_name]
+
+                if param_name in blind_params:
+                    values.append(0)
+                    errors.append(0)
+                else:
+                    values.append(param['value'])
+                    errors.append(param['error'])
+
+            y_offset = y_positions + (num_fits - 1) * bar_height / 2 - fit_idx * bar_height
+
+            ax.barh(
+                y_offset,
+                values,
+                bar_height,
+                xerr=errors,
+                label=version,
+                color=colors[fit_idx],
+                ecolor=colors[fit_idx],
+                alpha=0.8,
+                capsize=3
+            )
+
+        # Add horizontal lines between parameters
+        for i in range(num_params - 1):
+            ax.axhline(y=i + 0.5, color='gray', linestyle='--', linewidth=0.5, alpha=0.3)
+
+        ax.set_yticks(y_positions)
+        ax.set_yticklabels(param_names, fontsize=9)
+        ax.set_xlabel('Parameter value', fontsize=11)
+        ax.legend(loc='upper right', fontsize=10)
+        ax.grid(axis='x', alpha=0.3)
+        ax.set_xlim(-5.0, 5.0)
+        ax.axvline(x=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5)
+
+        plt.tight_layout()
+
+        plt.savefig(output_dir + f'/{output_basename}.png', dpi=150, bbox_inches='tight')
+        plt.savefig(output_dir + f'/{output_basename}.pdf', bbox_inches='tight')
+        plt.close(fig)
+
+    save_plot_for_parameters(all_param_names, 'fit_comparison_all')
+    save_plot_for_parameters(cms_param_names, 'fit_comparison_JME_NPs')
+    save_plot_for_parameters(other_param_names, 'fit_comparison_rest')
+
+def main():
     parser = argparse.ArgumentParser(
         description='Compare fit results across multiple JSON files'
     )
@@ -128,6 +137,10 @@ def create_comparison_plot(
         output = f"fit_comparison_{output_suffix}"
 
     output_dir = os.path.join(user.plot_directory, output)
+    helpers.copyIndexPHP(output_dir)
     
     create_comparison_plot(args.fit_files, output_dir, args.blind)
     print(f"Plots saved to {output_dir}")
+
+if __name__ == '__main__':
+    main()

From 3cbd9d5d105757b31b4b41c68d81e78fd005a4c0 Mon Sep 17 00:00:00 2001
From: Ricardo Barrue <ricardo.barrue@cern.ch>
Date: Thu, 23 Apr 2026 10:21:03 +0200
Subject: [PATCH 10/17] Pretty PNN closure plots: changing output directory

---
 ML/PNN/pnn_training_closure.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/ML/PNN/pnn_training_closure.py b/ML/PNN/pnn_training_closure.py
index ad73824..54a6a9a 100644
--- a/ML/PNN/pnn_training_closure.py
+++ b/ML/PNN/pnn_training_closure.py
@@ -212,9 +212,8 @@ def list_and_exit():
 
 plot_dir = os.path.join(
     user.plot_directory,
+    "PNN_training_closure",
     cfg_base + ("_for_debug" if args.for_debug else ""),
-    "training_closure",
-    "PNN",
     J["id"],
 )
 os.makedirs(plot_dir, exist_ok=True)

From 50142ba5c0c1a0179d2cbbd0db8a76acf2fd86a9 Mon Sep 17 00:00:00 2001
From: Ricardo Barrue <ricardo.barrue@cern.ch>
Date: Thu, 23 Apr 2026 10:22:48 +0200
Subject: [PATCH 11/17] BIT plots: truth-only plots

---
 plot/bit/bit_plot.py | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/plot/bit/bit_plot.py b/plot/bit/bit_plot.py
index 9d6b532..b87f1ab 100644
--- a/plot/bit/bit_plot.py
+++ b/plot/bit/bit_plot.py
@@ -91,6 +91,7 @@ def map_right_to_left(values, right_min, right_max, left_max):
 p.add_argument("config", help="Path to global YAML config")
 p.add_argument("--job", default=None, help="BIT job id to run (omit to list)")
 p.add_argument("--small", action="store_true", help=f"Only use the first {SMALL_MAX_EVENTS} selected events")
+p.add_argument("--truth_only", action="store_true", help="Only plot truth prediction")
 args = p.parse_args()
 
 
@@ -311,6 +312,10 @@ def list_and_exit():
 
 if args.small:
     out_dir = os.path.join(out_dir, "small")
+
+if args.truth_only:
+    out_dir += "_truth_only"
+
 os.makedirs(out_dir, exist_ok=True)
 
 print(f"Output directory: {out_dir}")
@@ -549,7 +554,8 @@ def list_and_exit():
         h_pred.SetMarkerStyle(0)
 
         h_truth.Draw("hist same")
-        h_pred.Draw("hist same")
+        if not args.truth_only:
+            h_pred.Draw("hist same")
 
         drawn_objects.extend([h_truth, h_pred])
 
@@ -635,7 +641,8 @@ def list_and_exit():
     dummy_pred.SetLineWidth(3)
 
     legend.AddEntry(dummy_truth, f"truth  {label}", "l")
-    legend.AddEntry(dummy_pred,  f"BIT  {label}",   "l")
+    if not args.truth_only:
+        legend.AddEntry(dummy_pred,  f"BIT  {label}",   "l")
 
     legend_objects.extend([dummy_truth, dummy_pred])
 

From 71ea02eee0dfeca58151a853edd6e3c2c8fe925a Mon Sep 17 00:00:00 2001
From: Ricardo Barrue <ricardo.barrue@cern.ch>
Date: Thu, 23 Apr 2026 10:23:10 +0200
Subject: [PATCH 12/17] PDF uncertainty comparison script

---
 plot/pdf/compare_pdfs.py | 157 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 157 insertions(+)
 create mode 100644 plot/pdf/compare_pdfs.py

diff --git a/plot/pdf/compare_pdfs.py b/plot/pdf/compare_pdfs.py
new file mode 100644
index 0000000..8d7c40b
--- /dev/null
+++ b/plot/pdf/compare_pdfs.py
@@ -0,0 +1,157 @@
+"""Create a two-panel comparison plot from one or more PDF result CSV files."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+from pathlib import Path
+
+from matplotlib.axes import Axes
+import matplotlib.pyplot as plt
+import pandas as pd
+
+import common.syncer as syncer
+import common.user as user
+import os
+
+
+LOGGER = logging.getLogger(__name__)
+
+def parse_series_entry(raw_series: str) -> tuple[str, Path]:
+    """Parse one --series entry into csv path and label."""
+
+    pieces = raw_series.split(":")
+    if len(pieces) < 2:
+        raise ValueError(
+            "Each --series entry must be 'label:path'. "
+            f"Invalid entry: {raw_series}"
+        )
+
+    csv_path = Path(pieces[0]).expanduser()
+    label = pieces[1].strip()
+
+    if not label:
+        raise ValueError(f"Series label cannot be empty: {raw_series}")
+
+    return label, csv_path
+
+
+def load_ratio_frame(csv_path: Path) -> pd.DataFrame:
+    """Load and validate a CSV file with x, ratio_q16, and ratio_q84 columns."""
+
+    frame = pd.read_csv(csv_path)
+    required_columns = {"x", "ratio_q16", "ratio_q84"}
+    missing_columns = required_columns.difference(frame.columns)
+    if missing_columns:
+        raise ValueError(
+            f"Missing columns in {csv_path}: {sorted(missing_columns)}. "
+            "Expected at least x, ratio_q16, ratio_q84."
+        )
+
+    return frame.sort_values("x")
+
+
+def plot_ratio_band(
+    axis: Axes,
+    frame: pd.DataFrame,
+    color: str,
+    line_style: str,
+    label: str | None = None,
+) -> None:
+    """Plot upper and lower ratio quantile curves on a given axis."""
+
+    axis.plot(
+        frame["x"],
+        frame["ratio_q84"],
+        color=color,
+        linestyle=line_style,
+        linewidth=1.5,
+        label=label,
+    )
+    axis.plot(
+        frame["x"],
+        frame["ratio_q16"],
+        color=color,
+        linestyle=line_style,
+        linewidth=1.5,
+    )
+
+
+if __name__ == "__main__":
+
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+
+    parser = argparse.ArgumentParser(
+        description="Plot ratio uncertainty bands from multiple CSV result files."
+    )
+    parser.add_argument(
+        "--series",
+        nargs="+",
+        required=True,
+        help=(
+            "Series entries in the form path:label. "
+            "Colors and line styles are assigned automatically. "
+            "Example: 'data/binned.csv:Binned' 'data/unbinned.csv:NSBI unbinned'"
+        ),
+    )
+    parser.add_argument("--output", help="Output image path, wrt user.plot_directory/gluonPDF_comparison/",required=True)
+    parser.add_argument("--q_value", default="1.65", help="Value of Q at which the results were derived (for label).")
+    parser.add_argument("--zoom-xmin", type=float, default=0.1, help="Zoom panel x minimum.")
+    parser.add_argument("--zoom-xmax", type=float, default=0.6, help="Zoom panel x maximum.")
+    parser.add_argument("--ymin", type=float, default=0.5, help="Shared y-axis minimum.")
+    parser.add_argument("--ymax", type=float, default=1.5, help="Shared y-axis maximum.")
+    args = parser.parse_args()
+    
+    # plt.style.use("seaborn-v0_8-whitegrid")
+    # plt.rcParams["axes.unicode_minus"] = False
+    figure, (axis_full, axis_zoom) = plt.subplots(
+        ncols=2,
+        figsize=(11, 3.8),
+        sharey=True,
+        constrained_layout=True,
+    )
+
+    colors = plt.rcParams["axes.prop_cycle"].by_key().get("color", ["C0", "C1", "C2", "C3"])
+    line_styles = ["-", "--", "-.", ":"]
+
+    for series_index, raw_series in enumerate(args.series):
+        label, csv_path = parse_series_entry(raw_series)
+        color = colors[series_index % len(colors)]
+        line_style = line_styles[(series_index // len(colors)) % len(line_styles)]
+        LOGGER.info("Loading %s", csv_path)
+        frame = load_ratio_frame(csv_path)
+        plot_ratio_band(axis_full, frame, color, line_style, label=label)
+
+        zoomed: pd.DataFrame = frame.loc[
+            (frame["x"] >= args.zoom_xmin) & (frame["x"] <= args.zoom_xmax)
+        ]
+        plot_ratio_band(axis_zoom, zoomed, color, line_style)
+
+    axis_full.set_xscale("log")
+    axis_full.set_xlim(left=0.005)
+    axis_full.set_ylim(args.ymin, args.ymax)
+    axis_full.set_xlabel("$x$")
+    axis_full.set_ylabel(r"$g/g^{(\mathrm{ref})}(x, Q)$")
+    axis_full.grid(True, which="major")
+    axis_full.legend(loc="upper center", frameon=True)
+
+    axis_zoom.set_xlim(args.zoom_xmin, args.zoom_xmax)
+    axis_zoom.set_xlabel("$x$")
+    axis_zoom.grid(True, which="major")
+    if args.q_value:
+        axis_zoom.text(
+            0.03,
+            0.93,
+            rf"$Q = {args.q_value}$ GeV",
+            transform=axis_zoom.transAxes,
+            fontsize=16,
+            va="top",
+            ha="left",
+        )
+
+    output_path = os.path.join(user.plot_directory,"gluonPDF_comparison")
+    os.makedirs(output_path, exist_ok=True)
+
+    plt.savefig(f"{output_path}/{args.output}.pdf", dpi=200)
+    plt.savefig(f"{output_path}/{args.output}.png", dpi=200)
+    syncer.sync()
\ No newline at end of file

From 889e2576046789b3faba282201986d07f821ad4d Mon Sep 17 00:00:00 2001
From: Ricardo Barrue <ricardo.barrue@cern.ch>
Date: Thu, 23 Apr 2026 11:23:59 +0200
Subject: [PATCH 13/17] BIT option: CLI argument for clipping (off by default)

---
 plot/bit/bit_plot.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/plot/bit/bit_plot.py b/plot/bit/bit_plot.py
index 94a1637..e44e914 100644
--- a/plot/bit/bit_plot.py
+++ b/plot/bit/bit_plot.py
@@ -107,6 +107,7 @@ def map_right_to_left(values, right_min, right_max, left_max):
 p.add_argument("--small", action="store_true", help=f"Only use the first {SMALL_MAX_EVENTS} selected events")
 p.add_argument("--truth_only", action="store_true", help="Only plot truth prediction")
 p.add_argument("--uncertainty", action="store_true", help=f"Plot uncertainties?")
+p.add_argument("--clip", action="store_true", help="Clip features used for surrogate evaluation to plot range.")
 args = p.parse_args()
 
 
@@ -553,7 +554,8 @@ def nuis_to_A_matrix(combinations, nuisance_toys, nuisance_name_to_idx):
 
             for syst_info in class_info["pnn"]:
                 X_syst = X[:, syst_info["column_mask"]].astype(np.float64, copy=True)
-                np.clip(X_syst, syst_info["clip_low"], syst_info["clip_high"], out=X_syst)
+                if args.clip:
+                    np.clip(X_syst, syst_info["clip_low"], syst_info["clip_high"], out=X_syst)
 
                 dA = predict_pnn_deltaA(
                     syst_info["predictor"],
@@ -620,7 +622,8 @@ def nuis_to_A_matrix(combinations, nuisance_toys, nuisance_name_to_idx):
                     for syst_info in class_info["pnn"]:
                         X_evt_raw = X[i_evt:i_evt+1, syst_info["column_mask"]].astype(np.float64, copy=True)
                         X_evt = X_evt_raw.copy()
-                        np.clip(X_evt, syst_info["clip_low"], syst_info["clip_high"], out=X_evt)
+                        if args.clip:
+                            np.clip(X_evt, syst_info["clip_low"], syst_info["clip_high"], out=X_evt)
 
                         dA_evt = predict_pnn_deltaA(
                             syst_info["predictor"],

From 72b77293e9e401baeafd5d0b52a1496487621c7d Mon Sep 17 00:00:00 2001
From: Ricardo Barrue <ricardo.barrue@cern.ch>
Date: Thu, 23 Apr 2026 11:29:53 +0200
Subject: [PATCH 14/17] Archiving superseded postfit plot script

---
 plot/postfitsys/{ => old}/remake_binned_fromfit.py | 0
 plot/postfitsys/{ => old}/remake_binned_fromfit.sh | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename plot/postfitsys/{ => old}/remake_binned_fromfit.py (100%)
 rename plot/postfitsys/{ => old}/remake_binned_fromfit.sh (100%)

diff --git a/plot/postfitsys/remake_binned_fromfit.py b/plot/postfitsys/old/remake_binned_fromfit.py
similarity index 100%
rename from plot/postfitsys/remake_binned_fromfit.py
rename to plot/postfitsys/old/remake_binned_fromfit.py
diff --git a/plot/postfitsys/remake_binned_fromfit.sh b/plot/postfitsys/old/remake_binned_fromfit.sh
similarity index 100%
rename from plot/postfitsys/remake_binned_fromfit.sh
rename to plot/postfitsys/old/remake_binned_fromfit.sh

From 9c420b4d5968e2e3ee28feaad1eb1dcf95605bd8 Mon Sep 17 00:00:00 2001
From: Ricardo Barrue <ricardo.barrue@cern.ch>
Date: Thu, 23 Apr 2026 11:51:27 +0200
Subject: [PATCH 15/17] Unf***ing commit history

---
 ML/BIT/GpuBIT.py                              |  253 +++
 ML/BIT/GpuMultiNode.py                        |  935 +++++++++++
 ML/BIT/NumbaBIT.py                            |   76 +-
 ML/BIT/NumbaMultiNode.py                      |  431 +++--
 ML/BIT/pdf_bit_training.py                    |  185 ++-
 common/directories.py                         |   20 +
 common/user.py                                |    6 +
 .../benchmark/unbinned_delphes_6_RunII.yaml   |   69 +
 configs/binned_v5D/binned_delphes_6.yaml      |  503 ++++++
 .../binned_v5D/binned_delphes_6_RunII.yaml    |  507 ++++++
 .../binned_v5D/binned_delphes_7_RunII.yaml    |  507 ++++++
 configs/binned_v6/binned_2016.yaml            |   12 +
 configs/binned_v6/binned_2016APV.yaml         |   12 +
 configs/binned_v6/binned_2017.yaml            |    8 +
 configs/binned_v6/binned_2018.yaml            |    4 +
 configs/unbinned_v5D/unbinned_delphes_1.yaml  | 1384 ++++++++++++++++
 configs/unbinned_v5D/unbinned_delphes_2.yaml  | 1384 ++++++++++++++++
 configs/unbinned_v5D/unbinned_delphes_3.yaml  | 1384 ++++++++++++++++
 .../unbinned_delphes_6_RunII.yaml             | 1388 +++++++++++++++++
 .../unbinned_delphes_7_RunII.yaml             | 1388 +++++++++++++++++
 configs/unbinned_v6/unbinned_2016.yaml        |   12 +
 configs/unbinned_v6/unbinned_2016APV.yaml     |   12 +
 configs/unbinned_v6/unbinned_2017.yaml        |    8 +
 configs/unbinned_v6/unbinned_2018.yaml        |    4 +
 data/RDataLoader.py                           |    7 +
 data/samples_RunII.py                         |   98 +-
 26 files changed, 10402 insertions(+), 195 deletions(-)
 create mode 100644 ML/BIT/GpuBIT.py
 create mode 100644 ML/BIT/GpuMultiNode.py
 create mode 100644 common/directories.py
 create mode 100644 configs/benchmark/unbinned_delphes_6_RunII.yaml
 create mode 100644 configs/binned_v5D/binned_delphes_6.yaml
 create mode 100644 configs/binned_v5D/binned_delphes_6_RunII.yaml
 create mode 100644 configs/binned_v5D/binned_delphes_7_RunII.yaml
 create mode 100644 configs/unbinned_v5D/unbinned_delphes_1.yaml
 create mode 100644 configs/unbinned_v5D/unbinned_delphes_2.yaml
 create mode 100644 configs/unbinned_v5D/unbinned_delphes_3.yaml
 create mode 100644 configs/unbinned_v5D/unbinned_delphes_6_RunII.yaml
 create mode 100644 configs/unbinned_v5D/unbinned_delphes_7_RunII.yaml

diff --git a/ML/BIT/GpuBIT.py b/ML/BIT/GpuBIT.py
new file mode 100644
index 0000000..a4a1758
--- /dev/null
+++ b/ML/BIT/GpuBIT.py
@@ -0,0 +1,253 @@
+#!/usr/bin/env python
+# Standard imports
+import sys
+import pickle
+import numpy as np
+import operator
+import functools
+
+sys.path.insert(0, '..'); sys.path.insert(0, '../..')
+import ML.BIT.GpuMultiNode as MultiNode
+
+default_cfg = {
+    "n_trees" : 100,
+    "learning_rate" : 0.2,
+    "loss" : "MSE",  # or "CrossEntropy"
+    "learn_global_score": False,
+}
+
+class MultiBoostedInformationTree:
+    """
+    Lightweight container for a boosted tree ensemble.
+
+    - Holds: cfg, node_cfg, and the trained trees.
+    - Does NOT hold training features, mutable training weights, base_points, or feature_names.
+    - Training is performed externally (e.g. in pdf_bit_training.py).
+    """
+
+    @staticmethod
+    def sort_comb(comb):
+        return tuple(sorted(comb))
+
+    def __init__(self, **kwargs):
+
+        # cfg and node_cfg from kwargs keys known by the Node
+        self.cfg = dict(default_cfg)  # avoid mutating the module-level default
+        self.node_cfg = {}
+
+        for (key, val) in kwargs.items():
+            if key in MultiNode.default_cfg.keys():
+                self.node_cfg[key] = val
+            elif key in default_cfg.keys():
+                self.cfg[key] = val
+            else:
+                raise RuntimeError("Got unexpected keyword arg: %s:%r" % (key, val))
+
+        self.node_cfg['loss'] = self.cfg['loss']
+
+        for (key, val) in self.cfg.items():
+            setattr(self, key, val)
+
+        # Attempt to learn 98%. (1-learning_rate)^n_trees = 0.02
+        if self.learning_rate == "auto":
+            self.learning_rate = 1 - 0.02**(1. / self.n_trees)
+
+        # Will hold the trees
+        self.trees = []
+
+        # Filled after first tree exists (or after load if missing)
+        self.derivatives = None
+
+    def _sanitize_after_load(self):
+        # Drop any legacy training-state / metadata attributes if present
+        for attr in ("training_features", "training_weights", "base_points", "feature_names"):
+            if hasattr(self, attr):
+                try:
+                    delattr(self, attr)
+                except Exception:
+                    pass
+
+        if not hasattr(self, "trees") or self.trees is None:
+            self.trees = []
+
+        if not hasattr(self, "cfg") or self.cfg is None:
+            self.cfg = dict(default_cfg)
+
+        if not hasattr(self, "node_cfg") or self.node_cfg is None:
+            self.node_cfg = {}
+
+        # Backfill common config attributes if missing
+        for k, v in default_cfg.items():
+            if not hasattr(self, k):
+                setattr(self, k, self.cfg.get(k, v))
+            self.cfg[k] = getattr(self, k)
+
+        # Backfill derivatives if missing and possible
+        if (not hasattr(self, "derivatives")) or (self.derivatives is None):
+            if len(self.trees) > 0:
+                try:
+                    self.derivatives = self.trees[0].derivatives[1:]
+                except Exception:
+                    self.derivatives = None
+
+    def __setstate__(self, state):
+        self.__dict__ = state
+        self._sanitize_after_load()
+
+    @classmethod
+    def load(cls, filename):
+        with open(filename, 'rb') as file_:
+            obj = pickle.load(file_)
+        if hasattr(obj, "_sanitize_after_load"):
+            obj._sanitize_after_load()
+        return obj
+
+    def save(self, filename):
+        with open(filename, 'wb') as file_:
+            pickle.dump(self, file_, protocol=pickle.HIGHEST_PROTOCOL)
+
+    def _build_prediction_cache(self):
+        split_feature_parts = []
+        split_value_parts = []
+        left_child_parts = []
+        right_child_parts = []
+        is_leaf_parts = []
+        leaf_value_parts = []
+        tree_offsets = [0]
+
+        for tree in self.trees:
+            if hasattr(tree, "_ensure_prediction_state"):
+                tree._ensure_prediction_state()
+                split_feature = tree._predict_split_feature
+                split_value = tree._predict_split_value
+                left_child = tree._predict_left_child
+                right_child = tree._predict_right_child
+                is_leaf = tree._predict_is_leaf
+                leaf_value = tree._predict_leaf_value
+            else:
+                tmp = tree.vectorized_predict(np.zeros((1, 1), dtype=np.float64))
+                raise RuntimeError(f"Tree {tree} does not expose prediction state; got tmp shape {tmp.shape}")
+
+            offset = tree_offsets[-1]
+            split_feature_parts.append(split_feature)
+            split_value_parts.append(split_value)
+            left_child_parts.append(np.where(left_child >= 0, left_child + offset, left_child))
+            right_child_parts.append(np.where(right_child >= 0, right_child + offset, right_child))
+            is_leaf_parts.append(is_leaf)
+            leaf_value_parts.append(leaf_value)
+            tree_offsets.append(offset + len(split_feature))
+
+        self._predict_tree_offsets = np.asarray(tree_offsets, dtype=np.int32)
+        if split_feature_parts:
+            self._predict_split_feature = np.concatenate(split_feature_parts).astype(np.int32, copy=False)
+            self._predict_split_value = np.concatenate(split_value_parts).astype(np.float64, copy=False)
+            self._predict_left_child = np.concatenate(left_child_parts).astype(np.int32, copy=False)
+            self._predict_right_child = np.concatenate(right_child_parts).astype(np.int32, copy=False)
+            self._predict_is_leaf = np.concatenate(is_leaf_parts).astype(np.int8, copy=False)
+            self._predict_leaf_value = np.concatenate(leaf_value_parts).astype(np.float64, copy=False)
+        else:
+            self._predict_split_feature = np.zeros(0, dtype=np.int32)
+            self._predict_split_value = np.zeros(0, dtype=np.float64)
+            self._predict_left_child = np.zeros(0, dtype=np.int32)
+            self._predict_right_child = np.zeros(0, dtype=np.int32)
+            self._predict_is_leaf = np.zeros(0, dtype=np.int8)
+            self._predict_leaf_value = np.zeros((0, 0), dtype=np.float64)
+        self._predict_cache_n_trees = len(self.trees)
+
+    def _ensure_prediction_cache(self):
+        if getattr(self, "_predict_cache_n_trees", None) != len(self.trees):
+            self._build_prediction_cache()
+
+    def predict(self, feature_array, max_n_tree=None, summed=True, last_tree_counts_full=False):
+        """
+        Parameters
+        ----------
+        feature_array : np.ndarray, shape (N, d)
+            Input features.
+        max_n_tree : int or None
+            Use only the first max_n_tree trees if set.
+        summed : bool
+            If True, returns the learning-rate-weighted sum over trees (shape (N, K)).
+            If False, returns per-tree predictions (shape (T, N, K)).
+        last_tree_counts_full : bool
+            If True and using all trees, set the last tree's learning rate to 1.
+        """
+        T = max_n_tree if max_n_tree is not None else self.n_trees
+        T = min(T, len(self.trees))
+
+        learning_rates = self.learning_rate * np.ones(T, dtype=np.float64)
+        if T > 0 and last_tree_counts_full and (max_n_tree is None or max_n_tree == self.n_trees) and (T == len(self.trees)):
+            learning_rates[-1] = 1.0
+        if self.cfg.get("learn_global_score", False) and T > 0:
+            learning_rates[0] = 1.0
+
+        if T == 0:
+            K = 0
+            if len(self.trees) > 0:
+                tmp = self.trees[0].vectorized_predict(feature_array[:1])
+                K = max(0, tmp.shape[1] - 1)
+            return np.zeros((feature_array.shape[0], K), dtype=np.float64) if summed else \
+                   np.zeros((0, feature_array.shape[0], K), dtype=np.float64)
+
+        first = self.trees[0].vectorized_predict(feature_array[:1])
+        K = first.shape[1] - 1
+        N = feature_array.shape[0]
+
+        if summed:
+            self._ensure_prediction_cache()
+            acc = np.zeros((N, K), dtype=np.float64)
+            kernel = MultiNode._predict_forest_ratio_numba_parallel if N >= 4096 else MultiNode._predict_forest_ratio_numba
+            kernel(
+                np.asarray(feature_array),
+                self._predict_tree_offsets[:T],
+                self._predict_split_feature,
+                self._predict_split_value,
+                self._predict_left_child,
+                self._predict_right_child,
+                self._predict_is_leaf,
+                self._predict_leaf_value,
+                learning_rates,
+                acc,
+            )
+            return acc
+        else:
+            out = np.empty((T, N, K), dtype=np.float64)
+            for t in range(T):
+                raw = self.trees[t].vectorized_predict(feature_array)
+                if raw.dtype != np.float64:
+                    raw = raw.astype(np.float64, copy=False)
+                denom = raw[:, :1]
+                num   = raw[:, 1:]
+                np.divide(num, denom, out=out[t], where=(denom != 0.0))
+                out[t] *= learning_rates[t]
+            return out
+
+#    def losses(self, feature_array, weight_dict, max_n_tree=None, last_tree_counts_full=False):
+#        """
+#        LEGACY / UNUSED (per your note).
+#
+#        This computes a tree-by-tree loss proxy using base_points and derivatives.
+#        It is kept only for backwards compatibility / occasional diagnostics.
+#
+#        IMPORTANT:
+#        - This function reads base_points from self.trees[0].base_points (stored inside the trained tree).
+#        - The BIT container itself does NOT store base_points.
+#
+#        If you truly never use it, you can delete it safely once you’re confident nothing calls it.
+#        """
+#        base_points      = self.trees[0].base_points
+#        base_point_const = np.array([[functools.reduce(operator.mul, [point[coeff] if (coeff in point) else 0 for coeff in der], 1)
+#                                      for der in self.derivatives] for point in base_points]).astype('float')
+#        for i_der, der in enumerate(self.derivatives):
+#            if not (len(der) == 2 and der[0] == der[1]): continue
+#            for i_point in range(len(base_points)):
+#                base_point_const[i_point][i_der] /= 2.
+#
+#        predictions = np.array([tree.vectorized_predict(feature_array) for tree in self.trees[:max_n_tree]])
+#        predictions = predictions[:, :, 1:] / np.expand_dims(predictions[:, :, 0], -1)
+#
+#        weight_ratio = np.array([(weight_dict[der] / weight_dict[()] if der in weight_dict else
+#                                  weight_dict[tuple(reversed(der))] / weight_dict[()])
+#                                 for der in self.derivatives]).transpose().astype('float')
+#
+#        return -(weight_dict[()][np.newaxis, ..., np.newaxis] * np.dot((predictions - (weight_ratio[np.newaxis, ...])), base_point_const) ** 2).sum(axis=(1, 2))
diff --git a/ML/BIT/GpuMultiNode.py b/ML/BIT/GpuMultiNode.py
new file mode 100644
index 0000000..a1220b7
--- /dev/null
+++ b/ML/BIT/GpuMultiNode.py
@@ -0,0 +1,935 @@
+#!/usr/bin/env python
+
+import numpy as np
+import operator 
+from math import sqrt
+import itertools
+import sys
+sys.path.insert(0,'..')
+sys.path.insert(0,'.')
+
+import functools
+
+# --- Numba setup (graceful fallback) ---
+try:
+    import numba
+    from numba import njit, prange
+    NUMBA_AVAILABLE = True
+except Exception:
+    NUMBA_AVAILABLE = False
+    def njit(*args, **kwargs):
+        def deco(f): return f
+        return deco
+    def prange(n): return range(n)
+
+try:
+    import cupy as cp
+    CUPY_AVAILABLE = True
+except Exception:
+    cp = None
+    CUPY_AVAILABLE = False
+
+default_cfg = {
+    "max_depth":        4,
+    "min_size" :        50,
+    "max_n_split":      -1,     # similar to TMVA
+    "base_points":      None,
+    "feature_names":    None,
+    "positive":         False,
+    "min_node_size_neg_adjust": False,
+    "loss" : "MSE", # or "CrossEntropy"
+    "_get_only_score":False,
+    "split_mode": "exact",   # "exact" (current) or "binned"
+    "n_bins": 256,           # used only if split_mode == "binned"
+    "quantile_bins": False,  # if True: quantile edges; else uniform edges
+
+}
+
+
+def _compute_global_quantile_cuts(feature_matrix, n_bins, cut_sample_rows=None):
+    if cut_sample_rows is None or cut_sample_rows <= 0 or cut_sample_rows >= feature_matrix.shape[0]:
+        sample = feature_matrix
+    else:
+        sample = feature_matrix[:cut_sample_rows]
+    quantile_levels = np.linspace(0.0, 1.0, int(n_bins) + 1, dtype=np.float64)[1:-1]
+    if quantile_levels.size == 0:
+        return np.zeros((feature_matrix.shape[1], 0), dtype=np.float32)
+    return np.quantile(sample, quantile_levels, axis=0).T.astype(np.float32)
+
+
+def _quantize_feature_matrix(feature_matrix, cuts):
+    bins = np.empty(feature_matrix.shape, dtype=np.uint16 if cuts.shape[1] + 1 > 256 else np.uint8)
+    for feature in range(feature_matrix.shape[1]):
+        bins[:, feature] = np.searchsorted(cuts[feature], feature_matrix[:, feature], side="left")
+    return bins
+
+
+def _child_cfg_without_cached_bins(cfg):
+    child_cfg = dict(cfg)
+    child_cfg.pop("binned_features", None)
+    return child_cfg
+
+# ------------------ Numba kernels for heavy numerics ------------------
+
+@njit(cache=True)
+def _rowdot(A, B_T):
+    # A: (n, d), B_T: (d, k)  -> (n, k)
+    return A @ B_T
+
+@njit(cache=True, parallel=True)
+def _mse_neg_loss_gains(sorted_weight_sums, sorted_weight_sums_right, base_point_const_T):
+    # Fused matmul + sum-of-squares: avoids allocating intermediate (n, k) matrices.
+    # Parallelised over rows (independent per split candidate).
+    n = sorted_weight_sums.shape[0]
+    d = sorted_weight_sums.shape[1]
+    k = base_point_const_T.shape[1]
+
+    gains = np.empty(n, dtype=np.float64)
+
+    for i in prange(n):
+        sL = 0.0
+        sR = 0.0
+        for j in range(k):
+            lij = 0.0
+            rij = 0.0
+            for m in range(d):
+                lij += sorted_weight_sums[i, m] * base_point_const_T[m, j]
+                rij += sorted_weight_sums_right[i, m] * base_point_const_T[m, j]
+            sL += lij * lij
+            sR += rij * rij
+        gains[i] = sL / sorted_weight_sums[i, 0] + sR / sorted_weight_sums_right[i, 0]
+
+    return gains
+
+@njit(cache=True, parallel=True)
+def _crossentropy_neg_loss_gains(sorted_weight_sums, sorted_weight_sums_right, base_point_const_T):
+    # Fused matmul + cross-entropy: avoids allocating intermediate (n, k) matrices.
+    # Parallelised over rows (independent per split candidate).
+    n = sorted_weight_sums.shape[0]
+    d = sorted_weight_sums.shape[1]
+    k = base_point_const_T.shape[1]
+
+    gains = np.empty(n, dtype=np.float64)
+
+    # avoid divide-by-zero by tiny eps (keeps parity with numpy nan_to_num behavior)
+    eps = 1e-300
+
+    for i in prange(n):
+        nL = sorted_weight_sums[i, 0]
+        nR = sorted_weight_sums_right[i, 0]
+        if nL <= 0.0 or nR <= 0.0:
+            gains[i] = -np.inf
+            continue
+
+        s = 0.0
+        for j in range(k):
+            # inline dot products
+            lij = 0.0
+            rij = 0.0
+            for m in range(d):
+                lij += sorted_weight_sums[i, m] * base_point_const_T[m, j]
+                rij += sorted_weight_sums_right[i, m] * base_point_const_T[m, j]
+
+            rL = lij / nL
+            rR = rij / nR
+            one_rL = 1.0 + rL
+            one_rR = 1.0 + rR
+
+            # clamp away from 0 to avoid log(0)
+            if one_rL == 0.0: one_rL = eps
+            if one_rR == 0.0: one_rR = eps
+            if rL == 0.0: rL = eps
+            if rR == 0.0: rR = eps
+
+            s += 0.5 * ( -2.0 * np.log(one_rL) + rL * ( 2.0 * (np.log(abs(rL)) - np.log(abs(one_rL))) ) )
+            s += 0.5 * ( -2.0 * np.log(one_rR) + rR * ( 2.0 * (np.log(abs(rR)) - np.log(abs(one_rR))) ) )
+
+        gains[i] = sorted_weight_sums[i, 0] * s
+    # shift by min to make positive (as in original)
+    # (Do it in Python caller to keep parity with np.nan_to_num etc.)
+    return gains
+
+@njit(cache=True, parallel=True)
+def _bin_sums_parallel(idx, TW, nbin):
+    """Accumulate weighted sums per bin without sorting.
+
+    Uses thread-local accumulators (no locks/atomics needed).
+    ~150x faster than argsort + fancy-index + reduceat for large N.
+
+    Parameters
+    ----------
+    idx : int64[N]   bin index (0 .. nbin-1) for each event
+    TW  : float64[N, D]  per-event weight vector
+    nbin : int        number of bins
+    """
+    N, D = TW.shape
+    nthreads = numba.get_num_threads()
+    chunk = (N + nthreads - 1) // nthreads
+    # Thread-local storage avoids race conditions without atomics
+    local_sums = np.zeros((nthreads, nbin, D), dtype=np.float64)
+    for t in prange(nthreads):
+        s = t * chunk
+        e_end = min(s + chunk, N)
+        for e in range(s, e_end):
+            b = idx[e]
+            for d in range(D):
+                local_sums[t, b, d] += TW[e, d]
+    # Reduce thread-local sums
+    bin_sums = np.zeros((nbin, D), dtype=np.float64)
+    for t in range(nthreads):
+        for b in range(nbin):
+            for d in range(D):
+                bin_sums[b, d] += local_sums[t, b, d]
+    return bin_sums
+
+
+@njit(cache=True)
+def _predict_tree_numba(feature_matrix, split_feature, split_value, left_child, right_child, is_leaf, leaf_value, out):
+    n_rows = feature_matrix.shape[0]
+    pred_dim = leaf_value.shape[1]
+    for i in range(n_rows):
+        node = 0
+        while is_leaf[node] == 0:
+            feature = split_feature[node]
+            if feature_matrix[i, feature] <= split_value[node]:
+                node = left_child[node]
+            else:
+                node = right_child[node]
+        for c in range(pred_dim):
+            out[i, c] = leaf_value[node, c]
+
+
+@njit(cache=True, parallel=True)
+def _predict_tree_numba_parallel(feature_matrix, split_feature, split_value, left_child, right_child, is_leaf, leaf_value, out):
+    n_rows = feature_matrix.shape[0]
+    pred_dim = leaf_value.shape[1]
+    for i in prange(n_rows):
+        node = 0
+        while is_leaf[node] == 0:
+            feature = split_feature[node]
+            if feature_matrix[i, feature] <= split_value[node]:
+                node = left_child[node]
+            else:
+                node = right_child[node]
+        for c in range(pred_dim):
+            out[i, c] = leaf_value[node, c]
+
+
+@njit(cache=True)
+def _predict_forest_ratio_numba(feature_matrix, tree_offsets, split_feature, split_value, left_child, right_child, is_leaf, leaf_value, learning_rates, out):
+    n_rows = feature_matrix.shape[0]
+    n_trees = learning_rates.shape[0]
+    pred_dim = out.shape[1]
+    for i in range(n_rows):
+        for c in range(pred_dim):
+            out[i, c] = 0.0
+        for t in range(n_trees):
+            node = tree_offsets[t]
+            while is_leaf[node] == 0:
+                feature = split_feature[node]
+                if feature_matrix[i, feature] <= split_value[node]:
+                    node = left_child[node]
+                else:
+                    node = right_child[node]
+            denom = leaf_value[node, 0]
+            if denom != 0.0:
+                lr = learning_rates[t]
+                for c in range(pred_dim):
+                    out[i, c] += lr * (leaf_value[node, c + 1] / denom)
+
+
+@njit(cache=True, parallel=True)
+def _predict_forest_ratio_numba_parallel(feature_matrix, tree_offsets, split_feature, split_value, left_child, right_child, is_leaf, leaf_value, learning_rates, out):
+    n_rows = feature_matrix.shape[0]
+    n_trees = learning_rates.shape[0]
+    pred_dim = out.shape[1]
+    for i in prange(n_rows):
+        for c in range(pred_dim):
+            out[i, c] = 0.0
+        for t in range(n_trees):
+            node = tree_offsets[t]
+            while is_leaf[node] == 0:
+                feature = split_feature[node]
+                if feature_matrix[i, feature] <= split_value[node]:
+                    node = left_child[node]
+                else:
+                    node = right_child[node]
+            denom = leaf_value[node, 0]
+            if denom != 0.0:
+                lr = learning_rates[t]
+                for c in range(pred_dim):
+                    out[i, c] += lr * (leaf_value[node, c + 1] / denom)
+
+# -------------------------------------------------------
+
+class MultiNode:
+    def __init__( self, features, training_weights, _depth=0, **kwargs):
+
+        ## basic BDT configuration + kwargs
+        self.cfg = dict(default_cfg)
+        self.cfg.update( kwargs )
+        for attr, val in self.cfg.items():
+            setattr( self, attr, val )
+
+        # data set
+        self.features           = features
+        self.split_bin          = -1
+        self.binned_features    = kwargs.get('binned_features', None)
+        self.precomputed_cuts   = kwargs.get('precomputed_cuts', None)
+        if self.features is not None:
+            self.size = len(self.features)
+            self.n_features = self.features.shape[1]
+        elif self.binned_features is not None:
+            self.size = len(self.binned_features)
+            self.n_features = self.binned_features.shape[1]
+        else:
+            raise RuntimeError("Need either features or binned_features for training.")
+
+        if self.cfg['loss'] not in ["MSE", "CrossEntropy"]:
+            raise RuntimeError( "Unknown loss. Should be 'MSE' or 'CrossEntropy'." ) 
+
+        # Master node: We expect a dict  
+        if type(training_weights)==dict:
+            self.coefficients            = sorted(list(set(sum(map(list,training_weights.keys()),[]))))
+
+            self.first_derivatives  = sorted(list(itertools.combinations_with_replacement(self.coefficients,1))) 
+            self.second_derivatives = sorted(list(itertools.combinations_with_replacement(self.coefficients,2))) 
+            self.derivatives        = [tuple()] + self.first_derivatives + self.second_derivatives
+
+            self.training_weights   = {tuple(sorted(key)):val for key,val in training_weights.items()}
+
+            assert ('base_points' in kwargs) and kwargs['base_points'] is not None, "Must provide base_points in cfg"
+            assert all( [ key in self.training_weights for key in self.derivatives ]), "Incomplete list of keys in training_weights?"
+
+            # precoumputed base_point_const
+            self.base_points      = kwargs['base_points']
+            self.base_point_const = np.array([[ functools.reduce(operator.mul, [point[coeff] if (coeff in point) else 0 for coeff in der ], 1) for der in self.derivatives] for point in self.base_points]).astype('float')
+            for i_der, der in enumerate(self.derivatives):
+                if not (len(der)==2 and der[0]==der[1]): continue
+                for i_point in range(len(self.base_points)):
+                    self.base_point_const[i_point][i_der]/=2.
+
+            assert np.linalg.matrix_rank(self.base_point_const) == self.base_point_const.shape[0], \
+                   "Base points not linearly independent! Found rank %i for %i base_points" %( np.linalg.matrix_rank(self.base_point_const), self.base_point_const.shape[0])
+
+            # make another version of base_point_const that contains the [1,0,0,...] vector -> used for testing positivity of the zeroth coefficient
+            const = np.zeros((1,len(self.derivatives)))
+            const[0,0]=1
+            self.base_point_const_for_pos = np.concatenate((const, self.base_point_const))
+
+            self.cfg['base_point_const']         = self.base_point_const
+            self.cfg['base_point_const_for_pos'] = self.base_point_const_for_pos
+            self.cfg['derivatives'] = self.derivatives 
+            self.cfg['feature_names'] = None if not ('feature_names' in kwargs) else kwargs['feature_names'] 
+            self.feature_names      = self.cfg['feature_names']
+            self.training_weights   = np.array([training_weights[der] for der in self.derivatives]).transpose().astype('float')
+        # inside tree -> we need not re-compute the base-point consts, we copy them
+        else:
+            self.training_weights           = training_weights
+            self.base_point_const           = kwargs['base_point_const']
+            self.base_point_const_for_pos   = kwargs['base_point_const_for_pos']
+            self.derivatives                = kwargs['derivatives']
+            self.feature_names              = kwargs['feature_names']
+
+        self.cfg.pop('binned_features', None)
+
+        # keep track of recursion depth
+        self._depth             = _depth
+
+        self.split(_depth=_depth)
+        self.prune()
+
+        # Let's not leak the dataset.
+        del self.training_weights
+        del self.features
+        del self.split_left_group
+        if hasattr(self, "binned_features"):
+            del self.binned_features
+        if hasattr(self, "precomputed_cuts"):
+            del self.precomputed_cuts
+
+    def _build_prediction_state(self):
+        split_feature = []
+        split_value = []
+        left_child = []
+        right_child = []
+        is_leaf = []
+        leaf_value = []
+
+        def visit(node):
+            node_id = len(split_feature)
+            split_feature.append(-1)
+            split_value.append(0.0)
+            left_child.append(-1)
+            right_child.append(-1)
+            is_leaf.append(0)
+            leaf_value.append(np.zeros(len(self.derivatives), dtype=np.float64))
+
+            if isinstance(node, ResultNode):
+                is_leaf[node_id] = 1
+                leaf_value[node_id] = np.asarray(node.coefficient_sum, dtype=np.float64)
+            else:
+                split_feature[node_id] = int(node.split_i_feature)
+                split_value[node_id] = float(node.split_value)
+                left_child[node_id] = visit(node.left)
+                right_child[node_id] = visit(node.right)
+            return node_id
+
+        visit(self)
+        self._predict_split_feature = np.asarray(split_feature, dtype=np.int32)
+        self._predict_split_value = np.asarray(split_value, dtype=np.float64)
+        self._predict_left_child = np.asarray(left_child, dtype=np.int32)
+        self._predict_right_child = np.asarray(right_child, dtype=np.int32)
+        self._predict_is_leaf = np.asarray(is_leaf, dtype=np.int8)
+        self._predict_leaf_value = np.asarray(leaf_value, dtype=np.float64)
+
+    def _ensure_prediction_state(self):
+        if not hasattr(self, "_predict_split_feature"):
+            self._build_prediction_state()
+
+#    def get_split_vectorized( self ):
+#        ''' determine where to split the features, with numba-accelerated FI maximization
+#        '''
+#
+#        # loop over the features ... assume the features consists of rows with [x1, x2, ...., xN]
+#        self.split_i_feature, self.split_value, self.split_gain, self.split_left_group = 0, -float('inf'), 0, None
+#
+#        # for a valid binary split, we need at least twice the mean size
+#        assert self.size >= 2*self.min_size
+#
+#        # precompute transposes used in kernels
+#        B_T  = self.base_point_const.transpose()
+#        loss_mode = self.cfg['loss']
+#
+#        for i_feature in range(len(self.features[0])):
+#            feature_values = self.features[:,i_feature]
+#
+#            feature_sorted_indices = np.argsort(feature_values)
+#            # cumulative sums along rows (sorted)
+#            sorted_weight_sums     = np.cumsum(self.training_weights[feature_sorted_indices],axis=0) # 2D cumsum
+#
+#            # respect min size for split & optional max_n_split
+#            if self.max_n_split<2:
+#                plateau_and_split_range_mask = np.ones(self.size-1, dtype=np.dtype('bool'))
+#            else:
+#                min_, max_ = float(np.min(feature_values)), float(np.max(feature_values))
+#                # create at most 'max_n_split' plateaus between min/max
+#                bins = np.linspace(min_, max_, self.max_n_split+2, endpoint=True)
+#                digit = np.digitize(feature_values[feature_sorted_indices], bins)
+#                plateau_and_split_range_mask = (digit[1:] != digit[:-1])
+#                plateau_and_split_range_mask = np.insert(plateau_and_split_range_mask, 0, False)[:-1]
+#
+#            if self.min_size > 1:
+#                plateau_and_split_range_mask[0:self.min_size-1] = False
+#                plateau_and_split_range_mask[-self.min_size+1:] = False
+#            plateau_and_split_range_mask &= (np.diff(feature_values[feature_sorted_indices]) != 0)
+#
+#            total_weight_sum         = sorted_weight_sums[-1]
+#            sorted_weight_sums       = sorted_weight_sums[0:-1]
+#            sorted_weight_sums_right = total_weight_sum-sorted_weight_sums
+#
+#            # mask negative definite splits
+#            if self.cfg['positive']:
+#                pos       = np.apply_along_axis(all, 1, np.dot(sorted_weight_sums,self.base_point_const_for_pos.transpose())>=0)
+#                pos_right = np.apply_along_axis(all, 1, np.dot(sorted_weight_sums_right,self.base_point_const_for_pos.transpose())>=0)
+#                plateau_and_split_range_mask &= pos
+#                plateau_and_split_range_mask &= pos_right
+#
+#            # Never allow negative yields
+#            plateau_and_split_range_mask &= (sorted_weight_sums[:,0]>0)
+#            plateau_and_split_range_mask &= (sorted_weight_sums_right[:,0]>0)
+#
+#            # --------- compute neg_loss_gains (JIT kernels) ----------
+#            if loss_mode == 'MSE':
+#                if NUMBA_AVAILABLE:
+#                    neg_loss_gains = _mse_neg_loss_gains(sorted_weight_sums, sorted_weight_sums_right, B_T)
+#                else:
+#                    L = sorted_weight_sums @ B_T
+#                    R = sorted_weight_sums_right @ B_T
+#                    neg_loss_gains = (np.sum(L*L, axis=1)/sorted_weight_sums[:,0]
+#                                      + np.sum(R*R, axis=1)/sorted_weight_sums_right[:,0])
+#            elif loss_mode == 'CrossEntropy':
+#                if NUMBA_AVAILABLE:
+#                    neg_loss_gains = _crossentropy_neg_loss_gains(sorted_weight_sums, sorted_weight_sums_right, B_T)
+#                    # shift by min to make positive (parity with original)
+#                    neg_loss_gains -= np.nanmin(neg_loss_gains)
+#                else:
+#                    with np.errstate(divide='ignore', invalid='ignore'):
+#                        r       = (sorted_weight_sums @ B_T)/sorted_weight_sums[:,0].reshape(-1,1)
+#                        r_right = (sorted_weight_sums_right @ B_T)/sorted_weight_sums_right[:,0].reshape(-1,1)
+#                        neg_loss_gains  = sorted_weight_sums[:,0]*np.sum( ( 0.5*np.log((1./(1.+r))**2) + r*0.5*np.log((r/(1.+r))**2) ), axis=1)
+#                        neg_loss_gains += sorted_weight_sums_right[:,0]*np.sum( ( 0.5*np.log((1./(1.+r_right))**2) + r_right*0.5*np.log((r_right/(1.+r_right))**2) ), axis=1)
+#                        neg_loss_gains -= np.nanmin(neg_loss_gains)
+#
+#            # Optional: min_node_size_neg_adjust (unchanged logic)
+#            if self.cfg['min_node_size_neg_adjust']:
+#                with np.errstate(divide='ignore', invalid='ignore'):
+#                    sorted_pos_sums       = np.cumsum( (self.training_weights[:,0]>0).astype('int')[feature_sorted_indices])
+#                    total_pos_sum         = sorted_pos_sums[-1]
+#                    sorted_pos_sums       = sorted_pos_sums[0:-1]
+#                    sorted_pos_sums_right = total_pos_sum-sorted_pos_sums
+#                    sorted_neg_sum       = np.arange(1, len(self.training_weights[:,0])) - sorted_pos_sums
+#                    sorted_neg_sum_right = np.arange(len(self.training_weights[:,0])-1,0,-1) - sorted_pos_sums_right
+#                    f      = sorted_neg_sum/np.maximum(sorted_pos_sums, 1).astype(float)
+#                    f_right= sorted_neg_sum_right/np.maximum(sorted_pos_sums_right, 1).astype(float)
+#
+#                    plateau_and_split_range_mask &= (np.arange(1, len(self.training_weights[:,0]))>(1+f)/(1-f)*self.min_size)
+#                    plateau_and_split_range_mask &= (np.arange(len(self.training_weights[:,0])-1,0,-1)>(1+f_right)/(1-f_right)*self.min_size)
+#
+#            gain_masked = np.nan_to_num(neg_loss_gains)*plateau_and_split_range_mask
+#            argmax_fi   = np.argmax(gain_masked)
+#            gain        = gain_masked[argmax_fi]
+#            value       = feature_values[feature_sorted_indices[argmax_fi]]
+#
+#            debug_self_split_gain = self.split_gain
+#            if gain > self.split_gain: 
+#                self.split_i_feature = i_feature
+#                self.split_value     = value
+#                self.split_gain      = gain
+#
+#            if np.count_nonzero(self.features[:,self.split_i_feature]<=self.split_value) == 1:
+#                print ("sorted_weight_sums[:,0]      ", sorted_weight_sums[:,0])
+#                print ("sorted_weight_sums_right[:,0]", sorted_weight_sums_right[:,0])
+#                print ("plateau_and_split_range_mask", plateau_and_split_range_mask)
+#                if loss_mode == 'MSE':
+#                    L = sorted_weight_sums @ B_T
+#                    R = sorted_weight_sums_right @ B_T
+#                    print ("neg_loss_gains left", np.sum(L*L,axis=1)/sorted_weight_sums[:,0] )
+#                    print ("neg_loss_gains right", np.sum(R*R,axis=1)/sorted_weight_sums_right[:,0])
+#                print ("neg_loss_gains", neg_loss_gains)
+#                print ("np.nan_to_num(neg_loss_gains)", np.nan_to_num(neg_loss_gains))
+#                print ("np.nan_to_num(neg_loss_gains)*plateau_and_split_range_mask", np.nan_to_num(neg_loss_gains)*plateau_and_split_range_mask)
+#                print ("argmax_fi", np.argmax(np.nan_to_num(neg_loss_gains)*plateau_and_split_range_mask) )
+#                print ("gain", gain )
+#                print ("found split?", gain > debug_self_split_gain, "gain", gain, "self.split_gain (before)",debug_self_split_gain, "self.split_gain(after)",self.split_gain)
+#                print ("self.split_left_group", self.features[:,self.split_i_feature]<=self.split_value if not  np.isnan(self.split_value) else np.ones(self.size, dtype='bool'))
+#                print ("non_zero", np.count_nonzero(self.features[:,self.split_i_feature]<=self.split_value if not  np.isnan(self.split_value) else np.ones(self.size, dtype='bool')))
+#                print ()
+#                assert False, "single-entry node!!"
+#
+#        assert not np.isnan(self.split_value)
+#
+#        self.split_left_group = self.features[:,self.split_i_feature]<=self.split_value if not  np.isnan(self.split_value) else np.ones(self.size, dtype='bool')
+
+    def get_split_vectorized( self ):
+        """Determine where to split the features.
+
+        Modes:
+          - exact  (default): current behavior (argsort + full cumsum over events)
+          - binned: bin feature values into n_bins, accumulate *weighted sums* per bin,
+                    do prefix sums over bins only, evaluate gains at bin boundaries.
+        """
+
+        self.split_i_feature, self.split_value, self.split_gain, self.split_left_group = 0, -float('inf'), 0, None
+
+        # for a valid binary split, we need at least twice the mean size (in events)
+        assert self.size >= 2*self.min_size
+
+        # precompute transposes used in kernels
+        B_T  = self.base_point_const.transpose()
+        loss_mode = self.cfg['loss']
+
+        mode = getattr(self, "split_mode", "exact")
+        if mode not in ("exact", "binned"):
+            mode = "exact"
+        n_bins = int(getattr(self, "n_bins", 256))
+        if n_bins < 2:
+            mode = "exact"
+        use_precomputed_bins = (
+            mode == "binned"
+            and getattr(self, "binned_features", None) is not None
+            and getattr(self, "precomputed_cuts", None) is not None
+        )
+
+        # convenience (used in both modes)
+        TW = self.training_weights  # shape (N, D)
+        TW_gpu = None
+        B_T_gpu = None
+        Mpos_gpu = None
+
+        if mode == "binned":
+            if not CUPY_AVAILABLE:
+                raise RuntimeError("Requested GPU backend but cupy is not available.")
+            TW_gpu = cp.asarray(TW, dtype=cp.float64)
+            B_T_gpu = cp.asarray(B_T, dtype=cp.float64)
+            if self.cfg['positive']:
+                Mpos_gpu = cp.asarray(self.base_point_const_for_pos.transpose(), dtype=cp.float64)
+
+        bins_gpu = cp.asarray(self.binned_features, dtype=cp.int32) if use_precomputed_bins else None
+
+        for i_feature in range(self.n_features):
+
+            # ------------------------ BINNED MODE ------------------------
+            if mode == "binned":
+                if use_precomputed_bins:
+                    cuts_i = self.precomputed_cuts[i_feature]
+                    nbin = int(cuts_i.shape[0] + 1)
+                    if nbin < 2:
+                        continue
+                    idx = bins_gpu[:, i_feature]
+                else:
+                    feature_values = self.features[:, i_feature]
+                    min_, max_ = float(np.min(feature_values)), float(np.max(feature_values))
+                    if not np.isfinite(min_) or not np.isfinite(max_) or max_ <= min_:
+                        continue
+                    quant = bool(getattr(self, "quantile_bins", False))
+
+                    if quant:
+                        qs = np.linspace(0.0, 1.0, n_bins + 1, endpoint=True)
+                        edges = np.quantile(feature_values, qs)
+                        edges = np.unique(edges)
+                        if edges.size < 3:
+                            continue
+                        nbin = int(edges.size - 1)
+                    else:
+                        edges = np.linspace(min_, max_, n_bins + 1, endpoint=True)
+                        nbin = int(n_bins)
+
+                    feature_values_gpu = cp.asarray(feature_values, dtype=cp.float64)
+                    edges_gpu = cp.asarray(edges, dtype=cp.float64)
+                    idx = cp.searchsorted(edges_gpu, feature_values_gpu, side="right") - 1
+                    idx = cp.clip(idx, 0, nbin - 1).astype(cp.int32, copy=False)
+
+                # per-bin event counts (for min_size constraint)
+                bin_counts = cp.bincount(idx, minlength=nbin).astype(cp.int64, copy=False)
+
+                # accumulate weighted sums per bin on GPU
+                bin_sums = cp.stack(
+                    [cp.bincount(idx, weights=TW_gpu[:, _d], minlength=nbin) for _d in range(TW.shape[1])],
+                    axis=1,
+                ).astype(cp.float64, copy=False)
+
+                # prefix sums over bins -> candidates are boundaries between bins
+                prefix_sums = cp.cumsum(bin_sums, axis=0)         # (nbin, D)
+                left_sums   = prefix_sums[:-1]                    # (nbin-1, D)
+                total_sum   = prefix_sums[-1]                     # (D,)
+                right_sums  = total_sum - left_sums               # (nbin-1, D)
+
+                prefix_cnt  = cp.cumsum(bin_counts)               # (nbin,)
+                left_cnt    = prefix_cnt[:-1]                     # (nbin-1,)
+                total_cnt   = prefix_cnt[-1]
+                right_cnt   = total_cnt - left_cnt                # (nbin-1,)
+
+                # candidate mask
+                mask = cp.ones(nbin - 1, dtype=cp.bool_)
+
+                # respect min_size in EVENTS (parity with original)
+                if self.min_size > 1:
+                    mask &= (left_cnt  >= self.min_size)
+                    mask &= (right_cnt >= self.min_size)
+
+                # optional negative-adjust logic (approximate in binned space)
+                if self.cfg['min_node_size_neg_adjust']:
+                    # count positives in column 0 per bin
+                    pos0 = (TW_gpu[:, 0] > 0).astype(cp.float64)
+                    pos_per_bin = cp.bincount(idx, weights=pos0, minlength=nbin).astype(cp.float64, copy=False)
+                    prefix_pos  = cp.cumsum(pos_per_bin)[:-1]
+                    left_pos    = prefix_pos
+                    right_pos   = cp.sum(pos_per_bin) - left_pos
+
+                    left_neg  = left_cnt.astype(cp.float64)  - left_pos
+                    right_neg = right_cnt.astype(cp.float64) - right_pos
+
+                    left_pos_safe  = cp.maximum(left_pos,  1.0)
+                    right_pos_safe = cp.maximum(right_pos, 1.0)
+                    f      = left_neg  / left_pos_safe
+                    f_right= right_neg / right_pos_safe
+
+                    mask &= (left_cnt.astype(cp.float64)  > (1+f)/(1-f) * self.min_size)
+                    mask &= (right_cnt.astype(cp.float64) > (1+f_right)/(1-f_right) * self.min_size)
+
+                # positivity constraints (use weighted sums, as in original)
+                if self.cfg['positive']:
+                    posL = cp.all((left_sums  @ Mpos_gpu) >= 0, axis=1)
+                    posR = cp.all((right_sums @ Mpos_gpu) >= 0, axis=1)
+                    mask &= posL
+                    mask &= posR
+
+                # Never allow negative yields (weighted yield is column 0)
+                mask &= (left_sums[:, 0]  > 0)
+                mask &= (right_sums[:, 0] > 0)
+
+                # --------- compute neg_loss_gains on GPU ----------
+                if loss_mode == 'MSE':
+                    L = left_sums @ B_T_gpu
+                    R = right_sums @ B_T_gpu
+                    neg_loss_gains = (cp.sum(L*L, axis=1)/left_sums[:,0]
+                                      + cp.sum(R*R, axis=1)/right_sums[:,0])
+
+                elif loss_mode == 'CrossEntropy':
+                    with cp.errstate(divide='ignore', invalid='ignore'):
+                        r       = (left_sums  @ B_T_gpu)/left_sums[:,0].reshape(-1,1)
+                        r_right = (right_sums @ B_T_gpu)/right_sums[:,0].reshape(-1,1)
+                        neg_loss_gains  = left_sums[:,0]*cp.sum((0.5*cp.log((1./(1.+r))**2) + r*0.5*cp.log((r/(1.+r))**2)), axis=1)
+                        neg_loss_gains += right_sums[:,0]*cp.sum((0.5*cp.log((1./(1.+r_right))**2) + r_right*0.5*cp.log((r_right/(1.+r_right))**2)), axis=1)
+                        neg_loss_gains -= cp.nanmin(neg_loss_gains)
+
+                gain_masked = cp.nan_to_num(neg_loss_gains) * mask.astype(neg_loss_gains.dtype, copy=False)
+                argmax_fi   = int(cp.asnumpy(cp.argmax(gain_masked)))
+                gain        = float(cp.asnumpy(gain_masked[argmax_fi]))
+
+                # split at boundary after bin argmax_fi
+                if use_precomputed_bins:
+                    value = float(cuts_i[argmax_fi])
+                else:
+                    value = edges[argmax_fi + 1]
+
+                if gain > self.split_gain:
+                    self.split_i_feature = i_feature
+                    self.split_value     = value
+                    self.split_gain      = gain
+                    self.split_bin       = int(argmax_fi)
+
+                continue  # next feature
+
+            # ------------------------ EXACT MODE (CURRENT) ------------------------
+            feature_values = self.features[:, i_feature]
+            feature_sorted_indices = np.argsort(feature_values)
+
+            sorted_weight_sums     = np.cumsum(TW[feature_sorted_indices], axis=0)  # (N, D)
+
+            # respect min size for split & optional max_n_split
+            if self.max_n_split < 2:
+                plateau_and_split_range_mask = np.ones(self.size-1, dtype=np.dtype('bool'))
+            else:
+                min_, max_ = float(np.min(feature_values)), float(np.max(feature_values))
+                bins = np.linspace(min_, max_, self.max_n_split+2, endpoint=True)
+                digit = np.digitize(feature_values[feature_sorted_indices], bins)
+                plateau_and_split_range_mask = (digit[1:] != digit[:-1])
+                plateau_and_split_range_mask = np.insert(plateau_and_split_range_mask, 0, False)[:-1]
+
+            if self.min_size > 1:
+                plateau_and_split_range_mask[0:self.min_size-1] = False
+                plateau_and_split_range_mask[-self.min_size+1:] = False
+            plateau_and_split_range_mask &= (np.diff(feature_values[feature_sorted_indices]) != 0)
+
+            total_weight_sum         = sorted_weight_sums[-1]
+            sorted_weight_sums       = sorted_weight_sums[0:-1]
+            sorted_weight_sums_right = total_weight_sum - sorted_weight_sums
+
+            # mask negative definite splits
+            if self.cfg['positive']:
+                Mpos = self.base_point_const_for_pos.transpose()
+                pos       = np.all((sorted_weight_sums       @ Mpos) >= 0, axis=1)
+                pos_right = np.all((sorted_weight_sums_right @ Mpos) >= 0, axis=1)
+                plateau_and_split_range_mask &= pos
+                plateau_and_split_range_mask &= pos_right
+
+            # Never allow negative yields
+            plateau_and_split_range_mask &= (sorted_weight_sums[:,0]       > 0)
+            plateau_and_split_range_mask &= (sorted_weight_sums_right[:,0] > 0)
+
+            # --------- compute neg_loss_gains (JIT kernels) ----------
+            if loss_mode == 'MSE':
+                if NUMBA_AVAILABLE:
+                    neg_loss_gains = _mse_neg_loss_gains(sorted_weight_sums, sorted_weight_sums_right, B_T)
+                else:
+                    L = sorted_weight_sums @ B_T
+                    R = sorted_weight_sums_right @ B_T
+                    neg_loss_gains = (np.sum(L*L, axis=1)/sorted_weight_sums[:,0]
+                                      + np.sum(R*R, axis=1)/sorted_weight_sums_right[:,0])
+
+            elif loss_mode == 'CrossEntropy':
+                if NUMBA_AVAILABLE:
+                    neg_loss_gains = _crossentropy_neg_loss_gains(sorted_weight_sums, sorted_weight_sums_right, B_T)
+                    neg_loss_gains -= np.nanmin(neg_loss_gains)
+                else:
+                    with np.errstate(divide='ignore', invalid='ignore'):
+                        r       = (sorted_weight_sums @ B_T)/sorted_weight_sums[:,0].reshape(-1,1)
+                        r_right = (sorted_weight_sums_right @ B_T)/sorted_weight_sums_right[:,0].reshape(-1,1)
+                        neg_loss_gains  = sorted_weight_sums[:,0]*np.sum( ( 0.5*np.log((1./(1.+r))**2) + r*0.5*np.log((r/(1.+r))**2) ), axis=1)
+                        neg_loss_gains += sorted_weight_sums_right[:,0]*np.sum( ( 0.5*np.log((1./(1.+r_right))**2) + r_right*0.5*np.log((r_right/(1.+r_right))**2) ), axis=1)
+                        neg_loss_gains -= np.nanmin(neg_loss_gains)
+
+            if self.cfg['min_node_size_neg_adjust']:
+                with np.errstate(divide='ignore', invalid='ignore'):
+                    sorted_pos_sums       = np.cumsum( (TW[:,0]>0).astype('int')[feature_sorted_indices])
+                    total_pos_sum         = sorted_pos_sums[-1]
+                    sorted_pos_sums       = sorted_pos_sums[0:-1]
+                    sorted_pos_sums_right = total_pos_sum - sorted_pos_sums
+                    sorted_neg_sum       = np.arange(1, len(TW[:,0])) - sorted_pos_sums
+                    sorted_neg_sum_right = np.arange(len(TW[:,0])-1,0,-1) - sorted_pos_sums_right
+                    f      = sorted_neg_sum/np.maximum(sorted_pos_sums, 1).astype(float)
+                    f_right= sorted_neg_sum_right/np.maximum(sorted_pos_sums_right, 1).astype(float)
+
+                    plateau_and_split_range_mask &= (np.arange(1, len(TW[:,0]))>(1+f)/(1-f)*self.min_size)
+                    plateau_and_split_range_mask &= (np.arange(len(TW[:,0])-1,0,-1)>(1+f_right)/(1-f_right)*self.min_size)
+
+            gain_masked = np.nan_to_num(neg_loss_gains) * plateau_and_split_range_mask
+            argmax_fi   = np.argmax(gain_masked)
+            gain        = gain_masked[argmax_fi]
+            value       = feature_values[feature_sorted_indices[argmax_fi]]
+
+            if gain > self.split_gain:
+                self.split_i_feature = i_feature
+                self.split_value     = value
+                self.split_gain      = gain
+                self.split_bin       = -1
+
+        assert not np.isnan(self.split_value)
+
+        if use_precomputed_bins and self.split_bin >= 0:
+            self.split_left_group = self.binned_features[:, self.split_i_feature] <= self.split_bin
+        else:
+            self.split_left_group = self.features[:,self.split_i_feature] <= self.split_value if not np.isnan(self.split_value) else np.ones(self.size, dtype='bool')
+
+
+    def coefficient_sum( self, group ):
+        return np.sum(self.training_weights[group],axis=0)
+
+    def negative_fraction( self, group ):
+        ''' lambda ~ omega*n = omega*(n^+ - n^-) -> this function returns ~ n^+/n^-
+        '''
+        neg = float(np.count_nonzero(self.training_weights[group][:,0]<0))
+        return neg/( len(group) - neg )
+
+    # everything we want to store in the terminal nodes
+    def __store( self, group ):
+        return {
+            'size': np.count_nonzero(group),
+            'coefficient_sum': self.coefficient_sum(group),
+            'f'   : self.negative_fraction(group), 
+            }
+
+    # Create child splits for a node or make terminal
+    def split(self, _depth=0):
+
+        # Find the best split
+        if self.cfg["_get_only_score"]:
+            # store derivatives in the left box and do not split further 
+            self.split_i_feature, self.split_value, self.split_left_group = 0, +float('inf'), None
+            self.split_bin    = -1
+            self.left        = ResultNode(derivatives=self.derivatives, **self.__store(np.ones(self.size,dtype=bool)))
+            self.right       = ResultNode(derivatives=self.derivatives, **self.__store(np.zeros(self.size,dtype=bool)))
+            return
+
+        self.get_split_vectorized()
+
+        # check for max depth or a 'no' split
+        if  self.max_depth <= _depth+1 or (not any(self.split_left_group)) or all(self.split_left_group):
+            # stop splitting further. Put everything in the left node
+            self.split_value = float('inf')
+            self.split_bin   = -1
+            self.left        = ResultNode(derivatives=self.derivatives, **self.__store(np.ones(self.size,dtype=bool)))
+            self.right       = ResultNode(derivatives=self.derivatives, **self.__store(np.zeros(self.size,dtype=bool)))
+            return
+
+        # process left child
+        if np.count_nonzero(self.split_left_group) < 2*self.min_size:
+            self.left             = ResultNode(derivatives=self.derivatives, **self.__store(self.split_left_group) )
+        else:
+            child_cfg = _child_cfg_without_cached_bins(self.cfg)
+            self.left             = MultiNode(
+                None if self.features is None else self.features[self.split_left_group],
+                training_weights = self.training_weights[self.split_left_group],
+                binned_features = None if self.binned_features is None else self.binned_features[self.split_left_group],
+                _depth=self._depth+1,
+                **child_cfg,
+            )
+        # process right child
+        if np.count_nonzero(~self.split_left_group) < 2*self.min_size:
+            self.right            = ResultNode(derivatives=self.derivatives, **self.__store(~self.split_left_group) )
+        else:
+            child_cfg = _child_cfg_without_cached_bins(self.cfg)
+            self.right            = MultiNode(
+                None if self.features is None else self.features[~self.split_left_group],
+                training_weights = self.training_weights[~self.split_left_group],
+                binned_features = None if self.binned_features is None else self.binned_features[~self.split_left_group],
+                _depth=self._depth+1,
+                **child_cfg,
+            )
+
+    # Prediction    
+    def predict( self, features):
+        ''' obtain the result by recursively descending down the tree
+        '''
+        node = self.left if features[self.split_i_feature]<=self.split_value else self.right
+        if isinstance(node, ResultNode):
+            return node.coefficient_sum 
+        else:
+            return node.predict(features)
+
+    def vectorized_predict(self, feature_matrix):
+        N = len(feature_matrix)
+        D = len(self.derivatives)
+        if N == 0:
+            return np.zeros((0, D), dtype=np.float64)
+
+        if not NUMBA_AVAILABLE:
+            predictions = np.zeros((N, D), dtype=np.float64)
+            stack = [(self, np.arange(N, dtype=np.intp))]
+            while stack:
+                node, indices = stack.pop()
+                if isinstance(node, ResultNode):
+                    predictions[indices] = node.coefficient_sum
+                else:
+                    go_left = feature_matrix[indices, node.split_i_feature] <= node.split_value
+                    left_idx  = indices[ go_left]
+                    right_idx = indices[~go_left]
+                    if len(right_idx):
+                        stack.append((node.right, right_idx))
+                    if len(left_idx):
+                        stack.append((node.left, left_idx))
+            return predictions
+
+        self._ensure_prediction_state()
+        predictions = np.empty((N, D), dtype=np.float64)
+        kernel = _predict_tree_numba_parallel if N >= 4096 else _predict_tree_numba
+        kernel(
+            np.asarray(feature_matrix),
+            self._predict_split_feature,
+            self._predict_split_value,
+            self._predict_left_child,
+            self._predict_right_child,
+            self._predict_is_leaf,
+            self._predict_leaf_value,
+            predictions,
+        )
+        return predictions
+
+    # remove the 'inf' splits
+    def prune( self ):
+        if not isinstance(self.left, ResultNode) and self.left.split_value==float('+inf'):
+            self.left = self.left.left
+        elif not isinstance(self.left, ResultNode):
+            self.left.prune()
+        if not isinstance(self.right, ResultNode) and self.right.split_value==float('+inf'):
+            self.right = self.right.left
+        elif not isinstance(self.right, ResultNode):
+            self.right.prune()
+
+    # Print a decision tree
+    def print_tree(self, _depth=0):
+        print('%s[%s <= %.3f]' % ((self._depth*' ', "X%d"%self.split_i_feature if self.feature_names is None else self.feature_names[self.split_i_feature], self.split_value)))
+        for node in [self.left, self.right]:
+            node.print_tree(_depth = _depth+1)
+
+    def get_list(self):
+        ''' recursively obtain all thresholds '''
+        return [ (self.split_i_feature, self.split_value), self.left.get_list(), self.right.get_list() ] 
+
+class ResultNode:
+    ''' Simple helper class to store result value.
+    '''
+    def __init__( self, derivatives=None, **kwargs):
+        for k, v in kwargs.items():
+            setattr( self, k, v)
+        self.derivatives     = derivatives
+
+    @staticmethod
+    def prefac(der):
+        return (0.5 if (len(der)==2 and len(set(der))==1) else 1. )
+
+    def print_tree(self, _depth=0):
+        r_poly_str = "".join(["*".join(["{:+.2e}".format(self.prefac(der)*self.coefficient_sum[i_der]/self.coefficient_sum[0])] + list(self.derivatives[i_der]) ) for i_der, der in enumerate(self.derivatives)])
+        c_poly_str = "".join(["*".join(["{:+.2e}".format(self.prefac(der)*self.coefficient_sum[i_der])] + list(self.derivatives[i_der]) ) for i_der, der in enumerate(self.derivatives)])
+        try:
+            unc = 1./sqrt(self.size)*sqrt((1+self.f)/(1-self.f))
+        except ZeroDivisionError:
+            unc = 0 
+        print_string = '%s(%6i, unc=%1.3f) r = %s   c = %s' % ((_depth)*' ', self.size, 1./sqrt(self.size)*sqrt((1+self.f)/(1-self.f)), r_poly_str, c_poly_str)
+        print(print_string)
+
+    def get_list(self):
+        ''' recursively obtain all thresholds (bottom of recursion)'''
+        return self.coefficient_sum 
diff --git a/ML/BIT/NumbaBIT.py b/ML/BIT/NumbaBIT.py
index 44adbbb..83f5e38 100644
--- a/ML/BIT/NumbaBIT.py
+++ b/ML/BIT/NumbaBIT.py
@@ -106,6 +106,58 @@ def save(self, filename):
         with open(filename, 'wb') as file_:
             pickle.dump(self, file_, protocol=pickle.HIGHEST_PROTOCOL)
 
+    def _build_prediction_cache(self):
+        split_feature_parts = []
+        split_value_parts = []
+        left_child_parts = []
+        right_child_parts = []
+        is_leaf_parts = []
+        leaf_value_parts = []
+        tree_offsets = [0]
+
+        for tree in self.trees:
+            if hasattr(tree, "_ensure_prediction_state"):
+                tree._ensure_prediction_state()
+                split_feature = tree._predict_split_feature
+                split_value = tree._predict_split_value
+                left_child = tree._predict_left_child
+                right_child = tree._predict_right_child
+                is_leaf = tree._predict_is_leaf
+                leaf_value = tree._predict_leaf_value
+            else:
+                tmp = tree.vectorized_predict(np.zeros((1, 1), dtype=np.float64))
+                raise RuntimeError(f"Tree {tree} does not expose prediction state; got tmp shape {tmp.shape}")
+
+            offset = tree_offsets[-1]
+            split_feature_parts.append(split_feature)
+            split_value_parts.append(split_value)
+            left_child_parts.append(np.where(left_child >= 0, left_child + offset, left_child))
+            right_child_parts.append(np.where(right_child >= 0, right_child + offset, right_child))
+            is_leaf_parts.append(is_leaf)
+            leaf_value_parts.append(leaf_value)
+            tree_offsets.append(offset + len(split_feature))
+
+        self._predict_tree_offsets = np.asarray(tree_offsets, dtype=np.int32)
+        if split_feature_parts:
+            self._predict_split_feature = np.concatenate(split_feature_parts).astype(np.int32, copy=False)
+            self._predict_split_value = np.concatenate(split_value_parts).astype(np.float64, copy=False)
+            self._predict_left_child = np.concatenate(left_child_parts).astype(np.int32, copy=False)
+            self._predict_right_child = np.concatenate(right_child_parts).astype(np.int32, copy=False)
+            self._predict_is_leaf = np.concatenate(is_leaf_parts).astype(np.int8, copy=False)
+            self._predict_leaf_value = np.concatenate(leaf_value_parts).astype(np.float64, copy=False)
+        else:
+            self._predict_split_feature = np.zeros(0, dtype=np.int32)
+            self._predict_split_value = np.zeros(0, dtype=np.float64)
+            self._predict_left_child = np.zeros(0, dtype=np.int32)
+            self._predict_right_child = np.zeros(0, dtype=np.int32)
+            self._predict_is_leaf = np.zeros(0, dtype=np.int8)
+            self._predict_leaf_value = np.zeros((0, 0), dtype=np.float64)
+        self._predict_cache_n_trees = len(self.trees)
+
+    def _ensure_prediction_cache(self):
+        if getattr(self, "_predict_cache_n_trees", None) != len(self.trees):
+            self._build_prediction_cache()
+
     def predict(self, feature_array, max_n_tree=None, summed=True, last_tree_counts_full=False):
         """
         Parameters
@@ -142,16 +194,21 @@ def predict(self, feature_array, max_n_tree=None, summed=True, last_tree_counts_
         N = feature_array.shape[0]
 
         if summed:
+            self._ensure_prediction_cache()
             acc = np.zeros((N, K), dtype=np.float64)
-            for t in range(T):
-                raw = self.trees[t].vectorized_predict(feature_array)  # (N, 1+K)
-                if raw.dtype != np.float64:
-                    raw = raw.astype(np.float64, copy=False)
-                denom = raw[:, :1]
-                num   = raw[:, 1:]
-                ratio = np.empty_like(num)
-                np.divide(num, denom, out=ratio, where=(denom != 0.0))
-                acc += learning_rates[t] * ratio
+            kernel = MultiNode._predict_forest_ratio_numba_parallel if N >= 4096 else MultiNode._predict_forest_ratio_numba
+            kernel(
+                np.asarray(feature_array),
+                self._predict_tree_offsets[:T],
+                self._predict_split_feature,
+                self._predict_split_value,
+                self._predict_left_child,
+                self._predict_right_child,
+                self._predict_is_leaf,
+                self._predict_leaf_value,
+                learning_rates,
+                acc,
+            )
             return acc
         else:
             out = np.empty((T, N, K), dtype=np.float64)
@@ -194,4 +251,3 @@ def predict(self, feature_array, max_n_tree=None, summed=True, last_tree_counts_
 #                                 for der in self.derivatives]).transpose().astype('float')
 #
 #        return -(weight_dict[()][np.newaxis, ..., np.newaxis] * np.dot((predictions - (weight_ratio[np.newaxis, ...])), base_point_const) ** 2).sum(axis=(1, 2))
-
diff --git a/ML/BIT/NumbaMultiNode.py b/ML/BIT/NumbaMultiNode.py
index e9acf47..638112a 100644
--- a/ML/BIT/NumbaMultiNode.py
+++ b/ML/BIT/NumbaMultiNode.py
@@ -13,13 +13,14 @@
 # --- Numba setup (graceful fallback) ---
 try:
     import numba
-    from numba import njit
+    from numba import njit, prange
     NUMBA_AVAILABLE = True
 except Exception:
     NUMBA_AVAILABLE = False
     def njit(*args, **kwargs):
         def deco(f): return f
         return deco
+    def prange(n): return range(n)
 
 default_cfg = {
     "max_depth":        4,
@@ -37,6 +38,30 @@ def deco(f): return f
 
 }
 
+
+def _compute_global_quantile_cuts(feature_matrix, n_bins, cut_sample_rows=None):
+    if cut_sample_rows is None or cut_sample_rows <= 0 or cut_sample_rows >= feature_matrix.shape[0]:
+        sample = feature_matrix
+    else:
+        sample = feature_matrix[:cut_sample_rows]
+    quantile_levels = np.linspace(0.0, 1.0, int(n_bins) + 1, dtype=np.float64)[1:-1]
+    if quantile_levels.size == 0:
+        return np.zeros((feature_matrix.shape[1], 0), dtype=np.float32)
+    return np.quantile(sample, quantile_levels, axis=0).T.astype(np.float32)
+
+
+def _quantize_feature_matrix(feature_matrix, cuts):
+    bins = np.empty(feature_matrix.shape, dtype=np.uint16 if cuts.shape[1] + 1 > 256 else np.uint8)
+    for feature in range(feature_matrix.shape[1]):
+        bins[:, feature] = np.searchsorted(cuts[feature], feature_matrix[:, feature], side="left")
+    return bins
+
+
+def _child_cfg_without_cached_bins(cfg):
+    child_cfg = dict(cfg)
+    child_cfg.pop("binned_features", None)
+    return child_cfg
+
 # ------------------ Numba kernels for heavy numerics ------------------
 
 @njit(cache=True)
@@ -44,46 +69,45 @@ def _rowdot(A, B_T):
     # A: (n, d), B_T: (d, k)  -> (n, k)
     return A @ B_T
 
-@njit(cache=True)
+@njit(cache=True, parallel=True)
 def _mse_neg_loss_gains(sorted_weight_sums, sorted_weight_sums_right, base_point_const_T):
-    # projections
-    L = _rowdot(sorted_weight_sums, base_point_const_T)
-    R = _rowdot(sorted_weight_sums_right, base_point_const_T)
+    # Fused matmul + sum-of-squares: avoids allocating intermediate (n, k) matrices.
+    # Parallelised over rows (independent per split candidate).
+    n = sorted_weight_sums.shape[0]
+    d = sorted_weight_sums.shape[1]
+    k = base_point_const_T.shape[1]
 
-    # rowwise sum of squares
-    n = L.shape[0]
-    k = L.shape[1]
-    left_ss = np.empty(n, dtype=np.float64)
-    right_ss = np.empty(n, dtype=np.float64)
+    gains = np.empty(n, dtype=np.float64)
 
-    for i in range(n):
+    for i in prange(n):
         sL = 0.0
         sR = 0.0
         for j in range(k):
-            sL += L[i, j] * L[i, j]
-            sR += R[i, j] * R[i, j]
-        left_ss[i]  = sL
-        right_ss[i] = sR
+            lij = 0.0
+            rij = 0.0
+            for m in range(d):
+                lij += sorted_weight_sums[i, m] * base_point_const_T[m, j]
+                rij += sorted_weight_sums_right[i, m] * base_point_const_T[m, j]
+            sL += lij * lij
+            sR += rij * rij
+        gains[i] = sL / sorted_weight_sums[i, 0] + sR / sorted_weight_sums_right[i, 0]
 
-    # divide by counts (first coefficient)
-    gains = left_ss / sorted_weight_sums[:, 0] + right_ss / sorted_weight_sums_right[:, 0]
     return gains
 
-@njit(cache=True)
+@njit(cache=True, parallel=True)
 def _crossentropy_neg_loss_gains(sorted_weight_sums, sorted_weight_sums_right, base_point_const_T):
-    # r = dot / N0, where N0 is column 0
-    L = _rowdot(sorted_weight_sums, base_point_const_T)
-    R = _rowdot(sorted_weight_sums_right, base_point_const_T)
-
-    n = L.shape[0]
-    k = L.shape[1]
+    # Fused matmul + cross-entropy: avoids allocating intermediate (n, k) matrices.
+    # Parallelised over rows (independent per split candidate).
+    n = sorted_weight_sums.shape[0]
+    d = sorted_weight_sums.shape[1]
+    k = base_point_const_T.shape[1]
 
     gains = np.empty(n, dtype=np.float64)
 
     # avoid divide-by-zero by tiny eps (keeps parity with numpy nan_to_num behavior)
     eps = 1e-300
 
-    for i in range(n):
+    for i in prange(n):
         nL = sorted_weight_sums[i, 0]
         nR = sorted_weight_sums_right[i, 0]
         if nL <= 0.0 or nR <= 0.0:
@@ -92,10 +116,15 @@ def _crossentropy_neg_loss_gains(sorted_weight_sums, sorted_weight_sums_right, b
 
         s = 0.0
         for j in range(k):
-            rL = L[i, j] / nL
-            rR = R[i, j] / nR
-            # original algebraic form (stable where defined):
-            # 0.5*log((1/(1+r))^2) + r*0.5*log((r/(1+r))^2)
+            # inline dot products
+            lij = 0.0
+            rij = 0.0
+            for m in range(d):
+                lij += sorted_weight_sums[i, m] * base_point_const_T[m, j]
+                rij += sorted_weight_sums_right[i, m] * base_point_const_T[m, j]
+
+            rL = lij / nL
+            rR = rij / nR
             one_rL = 1.0 + rL
             one_rR = 1.0 + rR
 
@@ -113,20 +142,141 @@ def _crossentropy_neg_loss_gains(sorted_weight_sums, sorted_weight_sums_right, b
     # (Do it in Python caller to keep parity with np.nan_to_num etc.)
     return gains
 
+@njit(cache=True, parallel=True)
+def _bin_sums_parallel(idx, TW, nbin):
+    """Accumulate weighted sums per bin without sorting.
+
+    Uses thread-local accumulators (no locks/atomics needed).
+    ~150x faster than argsort + fancy-index + reduceat for large N.
+
+    Parameters
+    ----------
+    idx : int64[N]   bin index (0 .. nbin-1) for each event
+    TW  : float64[N, D]  per-event weight vector
+    nbin : int        number of bins
+    """
+    N, D = TW.shape
+    nthreads = numba.get_num_threads()
+    chunk = (N + nthreads - 1) // nthreads
+    # Thread-local storage avoids race conditions without atomics
+    local_sums = np.zeros((nthreads, nbin, D), dtype=np.float64)
+    for t in prange(nthreads):
+        s = t * chunk
+        e_end = min(s + chunk, N)
+        for e in range(s, e_end):
+            b = idx[e]
+            for d in range(D):
+                local_sums[t, b, d] += TW[e, d]
+    # Reduce thread-local sums
+    bin_sums = np.zeros((nbin, D), dtype=np.float64)
+    for t in range(nthreads):
+        for b in range(nbin):
+            for d in range(D):
+                bin_sums[b, d] += local_sums[t, b, d]
+    return bin_sums
+
+
+@njit(cache=True)
+def _predict_tree_numba(feature_matrix, split_feature, split_value, left_child, right_child, is_leaf, leaf_value, out):
+    n_rows = feature_matrix.shape[0]
+    pred_dim = leaf_value.shape[1]
+    for i in range(n_rows):
+        node = 0
+        while is_leaf[node] == 0:
+            feature = split_feature[node]
+            if feature_matrix[i, feature] <= split_value[node]:
+                node = left_child[node]
+            else:
+                node = right_child[node]
+        for c in range(pred_dim):
+            out[i, c] = leaf_value[node, c]
+
+
+@njit(cache=True, parallel=True)
+def _predict_tree_numba_parallel(feature_matrix, split_feature, split_value, left_child, right_child, is_leaf, leaf_value, out):
+    n_rows = feature_matrix.shape[0]
+    pred_dim = leaf_value.shape[1]
+    for i in prange(n_rows):
+        node = 0
+        while is_leaf[node] == 0:
+            feature = split_feature[node]
+            if feature_matrix[i, feature] <= split_value[node]:
+                node = left_child[node]
+            else:
+                node = right_child[node]
+        for c in range(pred_dim):
+            out[i, c] = leaf_value[node, c]
+
+
+@njit(cache=True)
+def _predict_forest_ratio_numba(feature_matrix, tree_offsets, split_feature, split_value, left_child, right_child, is_leaf, leaf_value, learning_rates, out):
+    n_rows = feature_matrix.shape[0]
+    n_trees = learning_rates.shape[0]
+    pred_dim = out.shape[1]
+    for i in range(n_rows):
+        for c in range(pred_dim):
+            out[i, c] = 0.0
+        for t in range(n_trees):
+            node = tree_offsets[t]
+            while is_leaf[node] == 0:
+                feature = split_feature[node]
+                if feature_matrix[i, feature] <= split_value[node]:
+                    node = left_child[node]
+                else:
+                    node = right_child[node]
+            denom = leaf_value[node, 0]
+            if denom != 0.0:
+                lr = learning_rates[t]
+                for c in range(pred_dim):
+                    out[i, c] += lr * (leaf_value[node, c + 1] / denom)
+
+
+@njit(cache=True, parallel=True)
+def _predict_forest_ratio_numba_parallel(feature_matrix, tree_offsets, split_feature, split_value, left_child, right_child, is_leaf, leaf_value, learning_rates, out):
+    n_rows = feature_matrix.shape[0]
+    n_trees = learning_rates.shape[0]
+    pred_dim = out.shape[1]
+    for i in prange(n_rows):
+        for c in range(pred_dim):
+            out[i, c] = 0.0
+        for t in range(n_trees):
+            node = tree_offsets[t]
+            while is_leaf[node] == 0:
+                feature = split_feature[node]
+                if feature_matrix[i, feature] <= split_value[node]:
+                    node = left_child[node]
+                else:
+                    node = right_child[node]
+            denom = leaf_value[node, 0]
+            if denom != 0.0:
+                lr = learning_rates[t]
+                for c in range(pred_dim):
+                    out[i, c] += lr * (leaf_value[node, c + 1] / denom)
+
 # -------------------------------------------------------
 
 class MultiNode:
     def __init__( self, features, training_weights, _depth=0, **kwargs):
 
         ## basic BDT configuration + kwargs
-        self.cfg = default_cfg
+        self.cfg = dict(default_cfg)
         self.cfg.update( kwargs )
         for attr, val in self.cfg.items():
             setattr( self, attr, val )
 
         # data set
         self.features           = features
-        self.size               = len(self.features)
+        self.split_bin          = -1
+        self.binned_features    = kwargs.get('binned_features', None)
+        self.precomputed_cuts   = kwargs.get('precomputed_cuts', None)
+        if self.features is not None:
+            self.size = len(self.features)
+            self.n_features = self.features.shape[1]
+        elif self.binned_features is not None:
+            self.size = len(self.binned_features)
+            self.n_features = self.binned_features.shape[1]
+        else:
+            raise RuntimeError("Need either features or binned_features for training.")
 
         if self.cfg['loss'] not in ["MSE", "CrossEntropy"]:
             raise RuntimeError( "Unknown loss. Should be 'MSE' or 'CrossEntropy'." ) 
@@ -174,6 +324,8 @@ def __init__( self, features, training_weights, _depth=0, **kwargs):
             self.derivatives                = kwargs['derivatives']
             self.feature_names              = kwargs['feature_names']
 
+        self.cfg.pop('binned_features', None)
+
         # keep track of recursion depth
         self._depth             = _depth
 
@@ -182,8 +334,51 @@ def __init__( self, features, training_weights, _depth=0, **kwargs):
 
         # Let's not leak the dataset.
         del self.training_weights
-        del self.features 
-        del self.split_left_group 
+        del self.features
+        del self.split_left_group
+        if hasattr(self, "binned_features"):
+            del self.binned_features
+        if hasattr(self, "precomputed_cuts"):
+            del self.precomputed_cuts
+
+    def _build_prediction_state(self):
+        split_feature = []
+        split_value = []
+        left_child = []
+        right_child = []
+        is_leaf = []
+        leaf_value = []
+
+        def visit(node):
+            node_id = len(split_feature)
+            split_feature.append(-1)
+            split_value.append(0.0)
+            left_child.append(-1)
+            right_child.append(-1)
+            is_leaf.append(0)
+            leaf_value.append(np.zeros(len(self.derivatives), dtype=np.float64))
+
+            if isinstance(node, ResultNode):
+                is_leaf[node_id] = 1
+                leaf_value[node_id] = np.asarray(node.coefficient_sum, dtype=np.float64)
+            else:
+                split_feature[node_id] = int(node.split_i_feature)
+                split_value[node_id] = float(node.split_value)
+                left_child[node_id] = visit(node.left)
+                right_child[node_id] = visit(node.right)
+            return node_id
+
+        visit(self)
+        self._predict_split_feature = np.asarray(split_feature, dtype=np.int32)
+        self._predict_split_value = np.asarray(split_value, dtype=np.float64)
+        self._predict_left_child = np.asarray(left_child, dtype=np.int32)
+        self._predict_right_child = np.asarray(right_child, dtype=np.int32)
+        self._predict_is_leaf = np.asarray(is_leaf, dtype=np.int8)
+        self._predict_leaf_value = np.asarray(leaf_value, dtype=np.float64)
+
+    def _ensure_prediction_state(self):
+        if not hasattr(self, "_predict_split_feature"):
+            self._build_prediction_state()
 
 #    def get_split_vectorized( self ):
 #        ''' determine where to split the features, with numba-accelerated FI maximization
@@ -333,60 +528,57 @@ def get_split_vectorized( self ):
         n_bins = int(getattr(self, "n_bins", 256))
         if n_bins < 2:
             mode = "exact"
+        use_precomputed_bins = (
+            mode == "binned"
+            and getattr(self, "binned_features", None) is not None
+            and getattr(self, "precomputed_cuts", None) is not None
+        )
 
         # convenience (used in both modes)
         TW = self.training_weights  # shape (N, D)
 
-        for i_feature in range(len(self.features[0])):
-
-            feature_values = self.features[:, i_feature]
+        for i_feature in range(self.n_features):
 
             # ------------------------ BINNED MODE ------------------------
             if mode == "binned":
-
-                min_, max_ = float(np.min(feature_values)), float(np.max(feature_values))
-                if not np.isfinite(min_) or not np.isfinite(max_) or max_ <= min_:
-                    continue
-                # --- choose bin edges ---
-                quant = bool(getattr(self, "quantile_bins", False))
-
-                if quant:
-                    # quantile edges (can contain duplicates -> compress)
-                    qs = np.linspace(0.0, 1.0, n_bins + 1, endpoint=True)
-                    edges = np.quantile(feature_values, qs)
-                    edges = np.unique(edges)
-                    if edges.size < 3:
+                if use_precomputed_bins:
+                    idx = self.binned_features[:, i_feature]
+                    cuts_i = self.precomputed_cuts[i_feature]
+                    nbin = int(cuts_i.shape[0] + 1)
+                    if nbin < 2:
                         continue
-                    nbin = int(edges.size - 1)
                 else:
-                    # uniform edges
-                    edges = np.linspace(min_, max_, n_bins + 1, endpoint=True)
-                    nbin = int(n_bins)
+                    feature_values = self.features[:, i_feature]
+                    min_, max_ = float(np.min(feature_values)), float(np.max(feature_values))
+                    if not np.isfinite(min_) or not np.isfinite(max_) or max_ <= min_:
+                        continue
+                    quant = bool(getattr(self, "quantile_bins", False))
+
+                    if quant:
+                        qs = np.linspace(0.0, 1.0, n_bins + 1, endpoint=True)
+                        edges = np.quantile(feature_values, qs)
+                        edges = np.unique(edges)
+                        if edges.size < 3:
+                            continue
+                        nbin = int(edges.size - 1)
+                    else:
+                        edges = np.linspace(min_, max_, n_bins + 1, endpoint=True)
+                        nbin = int(n_bins)
 
-                # bin index in [0, nbin-1]
-                idx = np.searchsorted(edges, feature_values, side="right") - 1
-                idx[idx < 0] = 0
-                idx[idx >= nbin] = nbin - 1
+                    idx = np.searchsorted(edges, feature_values, side="right") - 1
+                    idx[idx < 0] = 0
+                    idx[idx >= nbin] = nbin - 1
 
                 # per-bin event counts (for min_size constraint)
                 bin_counts = np.bincount(idx, minlength=nbin).astype(np.int64)
 
-                # accumulate *weighted sums* per bin: shape (nbin, D)
-                # fast path: sort-by-bin, then reduceat over contiguous runs
-                order = np.argsort(idx, kind="mergesort")  # stable; helps reproducibility
-                idx_s = idx[order]
-                TW_s  = TW[order]
-
-                # run starts for each new bin id
-                # starts: [0, ...] indices where idx changes
-                change = np.flatnonzero(idx_s[1:] != idx_s[:-1]) + 1
-                starts = np.concatenate(([0], change))
-
-                run_bins = idx_s[starts]  # unique bin ids present
-                run_sums = np.add.reduceat(TW_s, starts, axis=0)  # (n_runs, D)
-
-                bin_sums = np.zeros((nbin, TW.shape[1]), dtype=np.float64)
-                bin_sums[run_bins] = run_sums
+                # accumulate weighted sums per bin without sorting
+                if NUMBA_AVAILABLE:
+                    bin_sums = _bin_sums_parallel(idx.astype(np.int64), TW, nbin)
+                else:
+                    bin_sums = np.zeros((nbin, TW.shape[1]), dtype=np.float64)
+                    for _d in range(TW.shape[1]):
+                        bin_sums[:, _d] = np.bincount(idx, weights=TW[:, _d], minlength=nbin)
 
                 # prefix sums over bins -> candidates are boundaries between bins
                 prefix_sums = np.cumsum(bin_sums, axis=0)         # (nbin, D)
@@ -465,17 +657,21 @@ def get_split_vectorized( self ):
                 argmax_fi   = np.argmax(gain_masked)
                 gain        = gain_masked[argmax_fi]
 
-                # split at boundary after bin argmax_fi
-                value = edges[argmax_fi + 1]
+                if use_precomputed_bins:
+                    value = float(cuts_i[argmax_fi])
+                else:
+                    value = edges[argmax_fi + 1]
 
                 if gain > self.split_gain:
                     self.split_i_feature = i_feature
                     self.split_value     = value
                     self.split_gain      = gain
+                    self.split_bin       = int(argmax_fi)
 
                 continue  # next feature
 
             # ------------------------ EXACT MODE (CURRENT) ------------------------
+            feature_values = self.features[:, i_feature]
             feature_sorted_indices = np.argsort(feature_values)
 
             sorted_weight_sums     = np.cumsum(TW[feature_sorted_indices], axis=0)  # (N, D)
@@ -556,10 +752,14 @@ def get_split_vectorized( self ):
                 self.split_i_feature = i_feature
                 self.split_value     = value
                 self.split_gain      = gain
+                self.split_bin       = -1
 
         assert not np.isnan(self.split_value)
 
-        self.split_left_group = self.features[:,self.split_i_feature] <= self.split_value if not np.isnan(self.split_value) else np.ones(self.size, dtype='bool')
+        if use_precomputed_bins and self.split_bin >= 0:
+            self.split_left_group = self.binned_features[:, self.split_i_feature] <= self.split_bin
+        else:
+            self.split_left_group = self.features[:,self.split_i_feature] <= self.split_value if not np.isnan(self.split_value) else np.ones(self.size, dtype='bool')
 
 
     def coefficient_sum( self, group ):
@@ -586,6 +786,7 @@ def split(self, _depth=0):
         if self.cfg["_get_only_score"]:
             # store derivatives in the left box and do not split further 
             self.split_i_feature, self.split_value, self.split_left_group = 0, +float('inf'), None
+            self.split_bin    = -1
             self.left        = ResultNode(derivatives=self.derivatives, **self.__store(np.ones(self.size,dtype=bool)))
             self.right       = ResultNode(derivatives=self.derivatives, **self.__store(np.zeros(self.size,dtype=bool)))
             return
@@ -596,6 +797,7 @@ def split(self, _depth=0):
         if  self.max_depth <= _depth+1 or (not any(self.split_left_group)) or all(self.split_left_group):
             # stop splitting further. Put everything in the left node
             self.split_value = float('inf')
+            self.split_bin   = -1
             self.left        = ResultNode(derivatives=self.derivatives, **self.__store(np.ones(self.size,dtype=bool)))
             self.right       = ResultNode(derivatives=self.derivatives, **self.__store(np.zeros(self.size,dtype=bool)))
             return
@@ -604,12 +806,26 @@ def split(self, _depth=0):
         if np.count_nonzero(self.split_left_group) < 2*self.min_size:
             self.left             = ResultNode(derivatives=self.derivatives, **self.__store(self.split_left_group) )
         else:
-            self.left             = MultiNode(self.features[self.split_left_group], training_weights = self.training_weights[self.split_left_group], _depth=self._depth+1, **self.cfg)
+            child_cfg = _child_cfg_without_cached_bins(self.cfg)
+            self.left             = MultiNode(
+                None if self.features is None else self.features[self.split_left_group],
+                training_weights = self.training_weights[self.split_left_group],
+                binned_features = None if self.binned_features is None else self.binned_features[self.split_left_group],
+                _depth=self._depth+1,
+                **child_cfg,
+            )
         # process right child
         if np.count_nonzero(~self.split_left_group) < 2*self.min_size:
             self.right            = ResultNode(derivatives=self.derivatives, **self.__store(~self.split_left_group) )
         else:
-            self.right            = MultiNode( self.features[~self.split_left_group], training_weights = self.training_weights[~self.split_left_group], _depth=self._depth+1, **self.cfg)
+            child_cfg = _child_cfg_without_cached_bins(self.cfg)
+            self.right            = MultiNode(
+                None if self.features is None else self.features[~self.split_left_group],
+                training_weights = self.training_weights[~self.split_left_group],
+                binned_features = None if self.binned_features is None else self.binned_features[~self.split_left_group],
+                _depth=self._depth+1,
+                **child_cfg,
+            )
 
     # Prediction    
     def predict( self, features):
@@ -622,31 +838,41 @@ def predict( self, features):
             return node.predict(features)
 
     def vectorized_predict(self, feature_matrix):
-        """Numpy path unchanged; still fastest for shallow trees.
-        """
-        emmitted_expressions_with_predictions = []
-
-        def emit_expressions_with_predictions(node, logical_expression):
-            if isinstance(node, ResultNode):
-                emmitted_expressions_with_predictions.append((logical_expression, node.coefficient_sum))
-            else:
-                if node == self:
-                    prepend = ""
-                else:
-                    prepend = " & "
-                if np.isinf(node.split_value):
-                    split_value_str = 'np.inf'
+        N = len(feature_matrix)
+        D = len(self.derivatives)
+        if N == 0:
+            return np.zeros((0, D), dtype=np.float64)
+
+        if not NUMBA_AVAILABLE:
+            predictions = np.zeros((N, D), dtype=np.float64)
+            stack = [(self, np.arange(N, dtype=np.intp))]
+            while stack:
+                node, indices = stack.pop()
+                if isinstance(node, ResultNode):
+                    predictions[indices] = node.coefficient_sum
                 else:
-                    split_value_str = format(node.split_value, '.32f')
-                emit_expressions_with_predictions(node.left, logical_expression + "%s(feature_matrix[:,%d] <= %s)" % (prepend, node.split_i_feature, split_value_str))
-                emit_expressions_with_predictions(node.right, logical_expression + "%s(feature_matrix[:,%d] > %s)" % (prepend, node.split_i_feature, split_value_str))
-
-        emit_expressions_with_predictions(self, "")
-        predictions = np.zeros((len(feature_matrix), len(self.derivatives)))
-
-        for expression, prediction in emmitted_expressions_with_predictions:
-            predictions[eval(expression)] = prediction
-
+                    go_left = feature_matrix[indices, node.split_i_feature] <= node.split_value
+                    left_idx  = indices[ go_left]
+                    right_idx = indices[~go_left]
+                    if len(right_idx):
+                        stack.append((node.right, right_idx))
+                    if len(left_idx):
+                        stack.append((node.left, left_idx))
+            return predictions
+
+        self._ensure_prediction_state()
+        predictions = np.empty((N, D), dtype=np.float64)
+        kernel = _predict_tree_numba_parallel if N >= 4096 else _predict_tree_numba
+        kernel(
+            np.asarray(feature_matrix),
+            self._predict_split_feature,
+            self._predict_split_value,
+            self._predict_left_child,
+            self._predict_right_child,
+            self._predict_is_leaf,
+            self._predict_leaf_value,
+            predictions,
+        )
         return predictions
 
     # remove the 'inf' splits
@@ -695,4 +921,3 @@ def print_tree(self, _depth=0):
     def get_list(self):
         ''' recursively obtain all thresholds (bottom of recursion)'''
         return self.coefficient_sum 
-
diff --git a/ML/BIT/pdf_bit_training.py b/ML/BIT/pdf_bit_training.py
index 931e2e4..a32df6b 100644
--- a/ML/BIT/pdf_bit_training.py
+++ b/ML/BIT/pdf_bit_training.py
@@ -14,10 +14,6 @@
 
 from pdf.PDFParametrization import PDFParametrization
 
-# Always NUMBA
-import numba as nb
-from ML.BIT.NumbaBIT import MultiBoostedInformationTree
-import ML.BIT.NumbaMultiNode as NumbaMultiNode
 
 from tqdm import trange, tqdm
 
@@ -28,12 +24,25 @@
 p = argparse.ArgumentParser(description="BIT training (YAML-driven)")
 p.add_argument("config", help="Path to global YAML config")
 p.add_argument("--job", default=None, help="BIT job id to run (omit to list)")
+p.add_argument("--postfix", default=None, help="Plot postfix")
 p.add_argument("--overwrite", action="store_true", help="Overwrite model file?")
 p.add_argument("--small", action="store_true", help="Only first shard for debugging")
+p.add_argument("--max_n_files", action="store",type=int, default=None, help="Only this numbe of files.")
 p.add_argument("--profile", action="store_true", help="Do CPU profiling?")
+p.add_argument("--gpu", action="store_true", help="Use GPU-accelerated binned split training backend.")
 p.add_argument("--every", default=5, type=int, help="When to plot (plot if tree_index % every == 0). Set <=0 to disable.")
 args = p.parse_args()
 
+
+# Always NUMBA
+import numba as nb
+if args.gpu:
+    from ML.BIT.GpuBIT import MultiBoostedInformationTree
+    import ML.BIT.GpuMultiNode as NumbaMultiNode
+else:
+    from ML.BIT.NumbaBIT import MultiBoostedInformationTree
+    import ML.BIT.NumbaMultiNode as NumbaMultiNode
+
 # ---------------- cfg ----------------
 cfg_path = os.path.expanduser(os.path.expandvars(args.config))
 CFG = yaml_loader.load_yaml(cfg_path)
@@ -66,8 +75,14 @@ def list_and_exit():
 loader_name = J.get("process")
 if not hasattr(samples_mod, loader_name):
     raise RuntimeError(f"Loader/view '{loader_name}' not found in module {module_samples}.")
+
 L = getattr(samples_mod, loader_name)
 
+if args.max_n_files is not None:
+    before = len(L._all_files)
+    L.set_max_files( args.max_n_files )
+    print(f"Reduced number of training files from {before} to {len(L._all_files)}")
+
 sel  = J.get("selection", None)
 sel_f= J.get("selection_features", [])
 if sel:
@@ -78,6 +93,22 @@ def list_and_exit():
 
 print("Using NUMBA")
 print("Numba threads:", nb.get_num_threads())
+if args.gpu:
+    try:
+        import cupy as cp
+        device_count = cp.cuda.runtime.getDeviceCount()
+        if device_count < 1:
+            raise RuntimeError("GPU training requested with --gpu, but no CUDA devices are visible.")
+        device_name = cp.cuda.runtime.getDeviceProperties(0)["name"].decode()
+    except Exception as e:
+        raise RuntimeError(
+            "GPU training requested with --gpu, but CuPy/CUDA initialization failed. "
+            "Ensure CuPy is installed and a CUDA device is available and accessible."
+        ) from e
+    print("Training backend: GPU")
+    print("GPU device:", device_name)
+else:
+    print("Training backend: CPU")
 
 # features
 L.setFeatures(J["features"])
@@ -269,25 +300,65 @@ def iterate_all(shard_limit=None):
         training_weights_valid = {k: v[:n_max_v] for k, v in training_weights_valid.items()}
 
 # ---------------- plotting function ----------------
-def plot_bit_training_root(bit, t, X_train, training_weights_train, feat_names, cfg_base, J):
-    """
-    Plot truth vs prediction ratios after t trees.
-    Syncer output is captured so tqdm bars remain usable.
-    """
+def _build_plot_context(X_train, training_weights_train, feat_names, cfg_base, J):
     import ROOT, math
     from data.plot_options import plot_options as PLOT_OPTS
 
     plot_feats = [f for f in feat_names if f in PLOT_OPTS]
     if not plot_feats:
-        tqdm.write("No plotable features found in PLOT_OPTS; skipping plots.")
-        return
+        return None
+
+    if args.max_n_files is not None:
+        train = f"train_maxFiles{args.max_n_files}"
+    else:
+        train = "train"
+    if args.postfix is not None:
+        train += ("_" + args.postfix)
 
-    out_dir = os.path.join(user.plot_directory, "BIT", cfg_base, J["id"], "train")
+    out_dir = os.path.join(user.plot_directory, "BIT", cfg_base, J["id"], train)
     os.makedirs(out_dir, exist_ok=True)
 
+    feat_cfgs = []
+    for feat in plot_feats:
+        n, lo, hi = PLOT_OPTS[feat]['binning']
+        feat_cfgs.append({
+            "name": feat,
+            "tex": PLOT_OPTS[feat]['tex'],
+            "n": n,
+            "lo": lo,
+            "hi": hi,
+            "edges": np.linspace(lo, hi, n + 1),
+            "column": feat_names.index(feat),
+        })
+
+    total_pads = len(plot_feats) + 1
+    gx = int(math.ceil(math.sqrt(total_pads)))
+    gy = int(math.ceil(total_pads / gx))
+
     ROOT.gStyle.SetOptStat(0)
     ROOT.gROOT.SetBatch(True)
 
+    return {
+        "out_dir": out_dir,
+        "feat_cfgs": feat_cfgs,
+        "gx": gx,
+        "gy": gy,
+        "w0": training_weights_train[()],
+    }
+
+
+def plot_bit_training_root(bit, t, X_train, training_weights_train, feat_names, cfg_base, J, plot_ctx=None):
+    """
+    Plot truth vs prediction ratios after t trees.
+    """
+    import ROOT
+
+    if plot_ctx is None:
+        plot_ctx = _build_plot_context(X_train, training_weights_train, feat_names, cfg_base, J)
+    if plot_ctx is None:
+        tqdm.write("No plotable features found in PLOT_OPTS; skipping plots.")
+        return False
+
     ders = bit.derivatives
 
     colors = {}
@@ -301,18 +372,15 @@ def plot_bit_training_root(bit, t, X_train, training_weights_train, feat_names,
             colors[der] = ROOT.kGreen + i_mix; i_mix += 1
 
     pred = bit.predict(X_train, max_n_tree=t)  # (N, M-1), aligned to ders[1:]
-    w0 = training_weights_train[()]
+    w0 = plot_ctx["w0"]
 
     truth_mat = np.stack([
         training_weights_train.get(der, training_weights_train.get(tuple(reversed(der))))
         for der in ders
     ], axis=1)
 
-    total_pads = len(plot_feats) + 1
-    gx = int(math.ceil(math.sqrt(total_pads)))
-    gy = int(math.ceil(total_pads / gx))
-    c = ROOT.TCanvas(f"c_iter_{t}", f"BIT iter {t}", 500*gx, 500*gy)
-    c.Divide(gx, gy)
+    c = ROOT.TCanvas(f"c_iter_{t}", f"BIT iter {t}", 500*plot_ctx["gx"], 500*plot_ctx["gy"])
+    c.Divide(plot_ctx["gx"], plot_ctx["gy"])
     keep = []
 
     leg = ROOT.TLegend(0.1, 0.1, 0.9, 0.9)
@@ -325,15 +393,18 @@ def _safe_ratio(numer, denom):
         denom2[denom2 == 0] = 1.0
         return numer / denom2
 
-    for i, feat in enumerate(plot_feats):
+    for i, feat_cfg in enumerate(plot_ctx["feat_cfgs"]):
         pad = c.cd(i + 1)
         pad.SetTicks(1, 1)
         pad.SetBottomMargin(0.15)
         pad.SetLeftMargin(0.15)
 
-        n, lo, hi = PLOT_OPTS[feat]['binning']
-        edges = np.linspace(lo, hi, n+1)
-        col = feat_names.index(feat)
+        feat = feat_cfg["name"]
+        n = feat_cfg["n"]
+        lo = feat_cfg["lo"]
+        hi = feat_cfg["hi"]
+        edges = feat_cfg["edges"]
+        col = feat_cfg["column"]
         x = X_train[:, col]
 
         h_w0, _ = np.histogram(x, bins=edges, weights=w0)
@@ -359,7 +430,7 @@ def _safe_ratio(numer, denom):
         y_low = y_min - pad_frac * (y_max - y_min)
         y_hi  = y_max + pad_frac * (y_max - y_min)
 
-        hframe = ROOT.TH2F(f"hf_{feat}_{t}", f";{PLOT_OPTS[feat]['tex']};ratio",
+        hframe = ROOT.TH2F(f"hf_{feat}_{t}", f";{feat_cfg['tex']};ratio",
                            n, lo, hi, 100, y_low, y_hi)
         hframe.GetYaxis().SetTitleOffset(1.3)
         hframe.Draw()
@@ -398,7 +469,7 @@ def _safe_ratio(numer, denom):
                 h.Draw("hist same")
                 keep.append(h)
 
-    pad = c.cd(len(plot_feats) + 1)
+    pad = c.cd(len(plot_ctx["feat_cfgs"]) + 1)
     pad.SetTicks(1, 1)
     pad.SetBottomMargin(0.15)
     pad.SetLeftMargin(0.15)
@@ -431,15 +502,9 @@ def _safe_ratio(numer, denom):
     tl.DrawLatex(0.30, 0.95, f"Trees = {t:04d}")
     keep.append(tl)
 
-    c.Print(os.path.join(out_dir, f"iter_{t:04d}.png"))
+    c.Print(os.path.join(plot_ctx["out_dir"], f"iter_{t:04d}.png"))
     c.Close()
-
-    buf = io.StringIO()
-    with contextlib.redirect_stdout(buf), contextlib.redirect_stderr(buf):
-        syncer.sync()
-    out = buf.getvalue().strip()
-    if out:
-        tqdm.write(out)
+    return True
 
 # ---------------- build & train BIT ----------------
 cfg_base = os.path.join(CFG.get("version", "default"), J['region'])
@@ -449,6 +514,8 @@ def _safe_ratio(numer, denom):
 model_path = os.path.join(model_dir, J.get("output", {}).get("filename", "BIT.pkl"))
 if args.small:
     model_path = model_path[:-4] + "_small.pkl"
+if args.max_n_files is not None:
+    model_path = model_path[:-4] + f"_maxFiles{args.max_n_files}.pkl"
 
 # weights snapshot stays separate (required to resume boosting correctly)
 weights_path = model_path[:-4] + ".weights.pkl"
@@ -512,6 +579,37 @@ def bit_ratio_mse_loss(bit, X, truth_weights, max_n_tree: int) -> float:
 
     return float(np.mean(losses))
 
+
+def _tree_summary(root, feat_names):
+    split_feature = feat_names[root.split_i_feature] if feat_names and root.split_i_feature < len(feat_names) else f"X{root.split_i_feature}"
+    split_gain = getattr(root, "split_gain", float("nan"))
+    left_size = int(getattr(root.left, "size", 0))
+    right_size = int(getattr(root.right, "size", 0))
+    return (
+        f"[TREE] root_feature={split_feature} "
+        f"threshold={root.split_value:.6g} "
+        f"gain={split_gain:.6g} "
+        f"left={left_size} right={right_size}"
+    )
+
+
+model_cfg = J.get("model", {}) or {}
+global_cuts = None
+bins_train = None
+if model_cfg.get("split_mode") == "binned":
+    cut_sample_rows = int(model_cfg.get("cut_sample_rows", len(X_train)))
+    cut_sample_rows = max(1, min(cut_sample_rows, len(X_train)))
+    global_cuts = NumbaMultiNode._compute_global_quantile_cuts(
+        X_train,
+        int(model_cfg.get("n_bins", 256)),
+        cut_sample_rows=cut_sample_rows,
+    )
+    bins_train = NumbaMultiNode._quantize_feature_matrix(X_train, global_cuts)
+    tqdm.write(
+        f"[BINS] built global cuts once: rows={cut_sample_rows} "
+        f"features={global_cuts.shape[0]} bins={global_cuts.shape[1] + 1}"
+    )
+
 # ---- load / resume from model_path directly ----
 if not args.overwrite and os.path.exists(model_path):
     try:
@@ -537,8 +635,7 @@ def bit_ratio_mse_loss(bit, X, truth_weights, max_n_tree: int) -> float:
 
 # ---- fresh init ----
 if bit is None:
-    mcfg = J.get("model", {}) or {}
-    bit = MultiBoostedInformationTree(**mcfg)
+    bit = MultiBoostedInformationTree(**model_cfg)
     boost_weights = {k: v.copy() for k, v in training_weights_train.items()}
 
 # If training needed but weights missing, start from truth
@@ -548,6 +645,7 @@ def bit_ratio_mse_loss(bit, X, truth_weights, max_n_tree: int) -> float:
 # ---------------- external training loop ----------------
 rt = J.get("runtime", {}) or {}
 enable_plots = bool(rt.get("training_plots", False))
+plot_ctx = _build_plot_context(X_train, training_weights_train, feat_names, cfg_base, J) if enable_plots else None
 
 # ---------------- loss history ----------------
 loss_trees = []
@@ -560,6 +658,9 @@ def bit_ratio_mse_loss(bit, X, truth_weights, max_n_tree: int) -> float:
 
 if len(bit.trees) < bit.n_trees:
 
+    if global_cuts is not None:
+        bit.node_cfg["precomputed_cuts"] = global_cuts
+
     weak_learner_time = 0.0
     update_time = 0.0
 
@@ -580,14 +681,16 @@ def bit_ratio_mse_loss(bit, X, truth_weights, max_n_tree: int) -> float:
         # fit tree (root needs base_points / feature_names)
         t1 = time.process_time()
         root = NumbaMultiNode.MultiNode(
-            X_train,
+            None if global_cuts is not None else X_train,
             training_weights = boost_weights,
             base_points      = base_points,
             feature_names    = feat_names,
+            binned_features  = bins_train,
             **bit.node_cfg
         )
         t2 = time.process_time()
         weak_learner_time += (t2 - t1)
+        tqdm.write(_tree_summary(root, feat_names))
 
         # ---------------- end profiling ----------------
         if args.profile:
@@ -699,8 +802,16 @@ def bit_ratio_mse_loss(bit, X, truth_weights, max_n_tree: int) -> float:
         do_plot = enable_plots and (args.every is not None) and (args.every > 0) and ((n_tree % args.every) == 0)
         if do_plot:
             tqdm.write(f"Plotting at tree {n_tree+1:04d} ...")
-            plot_bit_training_root(bit, t=n_tree+1, X_train=X_train, training_weights_train=training_weights_train,
-                                   feat_names=feat_names, cfg_base=cfg_base, J=J)
+            plot_bit_training_root(
+                bit,
+                t=n_tree+1,
+                X_train=X_train,
+                training_weights_train=training_weights_train,
+                feat_names=feat_names,
+                cfg_base=cfg_base,
+                J=J,
+                plot_ctx=plot_ctx,
+            )
 
     # ---------------- save loss history ----------------
     loss_txt = os.path.join(model_dir, "loss_history.txt")
diff --git a/common/directories.py b/common/directories.py
new file mode 100644
index 0000000..d2d7fe9
--- /dev/null
+++ b/common/directories.py
@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import socket
+from pathlib import Path
+
+
+_HOSTNAME = socket.gethostname()
+
+
+# Keep the default paths as the default. Only switch explicitly on hepgpu2.
+SAMPLES_RUNII_BASE_DIRECTORY = Path(
+    "/groups/hephy/cms/robert.schoefbeck/CMGRDF_ntuples/v2-3-2_nJ2p_nB2p_2l/"
+)
+
+DELPHES_TT2L_DIRECTORY = Path(
+    "/scratch-cbe/users/robert.schoefbeck/TT2lUnbinned/nanoTuples/delphes/v1/TTLep_pow_selected/"
+)
+
+if "hepgpu2" in _HOSTNAME:
+    DELPHES_TT2L_DIRECTORY = Path("/scratch/rschoefbeck/TTLep_pow_selected/")
diff --git a/common/user.py b/common/user.py
index cd84052..6d03ec0 100644
--- a/common/user.py
+++ b/common/user.py
@@ -61,6 +61,12 @@
     
 
 
+elif user in ['rschoefbeck']:
+    plot_directory         = "/home/rschoefbeck/HEPHY-Uncertainty/plots/"
+    model_directory        = "/scratch/rschoefbeck/HEPHY-Uncertainty/models/"
+    cache_directory        = "/scratch/rschoefbeck/HEPHY-Uncertainty/caches/"
+    output_directory       = "/scratch/rschoefbeck/HEPHY-Uncertainty/output/"
+
 else:
 
     raise RuntimeError( "HELLO NEW USER! Configure your directories in common/user.py! Look in the file how others did it." )
diff --git a/configs/benchmark/unbinned_delphes_6_RunII.yaml b/configs/benchmark/unbinned_delphes_6_RunII.yaml
new file mode 100644
index 0000000..7e83f7f
--- /dev/null
+++ b/configs/benchmark/unbinned_delphes_6_RunII.yaml
@@ -0,0 +1,69 @@
+version: unbinned_v5D_benchmark
+
+defaults:
+  module_samples: "data.samples_RunII"
+  default_features:
+    - TOP_KINEMATICS
+    - LEPTON_KINEMATICS
+    - ASYMMETRY
+
+  splitting:
+    enabled: true
+    uid_fields: ["run", "luminosityBlock", "event"]
+    seed: 42
+    n_buckets: 10000 
+
+    scheme:
+      pnn_train:     { fraction: 0.50 }
+      pnn_val:       { fraction: 0.10 }
+      c2st_train:    { fraction: 0.15 }
+      c2st_val:      { fraction: 0.05 }
+      final_eval:    { fraction: 0.20 }
+
+  early_stopping:
+    enabled: true
+    patience: 20        # same as current hard-coded
+    min_delta: 0.0      # improvement threshold; keep 0.0 to match current behavior
+    mode: "min"         # val_loss should decrease
+    warmup_epochs: 0    # optional: do not early-stop before this epoch
+
+
+likelihood:
+    regions:
+        - id: SR 
+          classifier:
+            type: null
+            id: null    # no classifier needed for a single process
+            asimov: [tt2l_delphes_RunII]
+          classes: 
+            - id: tt2l_delphes
+              sample: tt2l_delphes_RunII 
+              POI:
+                job: bit_NG_PDF4LHC21_6_tt2l_delphes 
+                type: bit
+                parameters: [c0, c1, c2, c3, c4, c5]
+
+
+jobs:
+  - id: bit_NG_PDF4LHC21_6_tt2l_delphes
+    type: bit
+    region: SR
+    process: tt2l_delphes_RunII
+    selection: null               # optional extra selection layered on top
+    numba: True
+    pdf:
+      pdf_n: [1,2,3,4,5,6]
+      pdf_type: PODBasis
+      pdf_basis: gluon_POD_nongluon_PDF4LHC21 
+    model:
+      n_trees: 20
+      learning_rate: 0.2
+      loss: MSE                   # or "CrossEntropy"
+      learn_global_score: true
+      split_mode: "binned"
+      n_bins: 256
+      quantile_bins: true  # if True: quantile edges; else uniform edges
+    runtime:
+      training_plots: true        # keep if you want training plots
+    output:
+      filename: "BIT_NG_PDF4LHC21_6_tt2l_delphes.pkl"
diff --git a/configs/binned_v5D/binned_delphes_6.yaml b/configs/binned_v5D/binned_delphes_6.yaml
new file mode 100644
index 0000000..3f60987
--- /dev/null
+++ b/configs/binned_v5D/binned_delphes_6.yaml
@@ -0,0 +1,503 @@
+version: binned_delphes_v5D
+
+defaults:
+  module_samples: "data.samples_RunII"
+  default_binning:
+    - ["tr_ttbar_mass", [300, 400, 500, 650, 1500]]
+    - ["tr_ttbar_y", [-2.5, -1.2, -0.8, -0.4, 0.4, 0.8, 1.2, 2.5]]
+        
+likelihood:
+    binned:
+        - id: SR 
+          classes: 
+            - id: tt2l_delphes 
+              sample: tt2l_delphes
+              POI:
+                job: ich_NG_PDF4LHC21_6_tt2l_delphes 
+                type: ich
+                parameters: [c0, c1, c2, c3, c4, c5]
+              systematics:
+                - id: L1Prefire
+                  type: icph
+                  job: icph_TTLep_pow_2016_L1Prefire
+                  parameters: [nu_l1prefire]
+                - id: PU
+                  type: icph
+                  job: icph_TTLep_pow_2016_PU
+                  parameters: [nu_pu]
+                - id: MuSF 
+                  type: icph
+                  job: icph_TTLep_pow_2016_MuSF
+                  parameters: [nu_MuSF]
+                - id: EleSF
+                  type: icph
+                  job: icph_TTLep_pow_2016_EleSF
+                  parameters: [nu_EleSF]
+                - id: BTag_b
+                  type: icph
+                  job: icph_TTLep_pow_2016_BTag_b
+                  parameters: [nu_btag_b]
+                - id: BTag_l
+                  type: icph
+                  job: icph_TTLep_pow_2016_BTag_l
+                  parameters: [nu_btag_l]
+                - id: Scales
+                  type: icph
+                  job: icph_TTLep_pow_2016_scales
+                  parameters: [nu_mu_ren, nu_mu_fac]
+                - id: ShowerISR
+                  type: icph
+                  job: icph_TTLep_pow_2016_showerISR
+                  parameters: [nu_showerISR]
+                - id: ShowerFSR
+                  type: icph
+                  job: icph_TTLep_pow_2016_showerFSR
+                  parameters: [nu_showerFSR]
+                - id: AlphaS
+                  type: icph
+                  job: icph_TTLep_pow_2016_alphaS
+                  parameters: [nu_alphaS]
+                - id: CMS_res_j_0
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_res_j_0_2016
+                  parameters: [nu_CMS_res_j_0]
+                - id: CMS_res_j_1
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_res_j_1_2016
+                  parameters: [nu_CMS_res_j_1]
+                - id: CMS_res_j_2
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_res_j_2_2016
+                  parameters: [nu_CMS_res_j_2]
+                - id: CMS_res_j_3
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_res_j_3_2016
+                  parameters: [nu_CMS_res_j_3]
+                - id: CMS_res_j_4
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_res_j_4_2016
+                  parameters: [nu_CMS_res_j_4]
+                - id: CMS_res_j_5
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_res_j_5_2016
+                  parameters: [nu_CMS_res_j_5]
+                - id: CMS_scale_j_Total_EtaBin0
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+                  parameters: [nu_CMS_scale_j_Total_EtaBin0]
+                - id: CMS_scale_j_Total_EtaBin1
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+                  parameters: [nu_CMS_scale_j_Total_EtaBin1]
+                - id: CMS_scale_j_Total_EtaBin2
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+                  parameters: [nu_CMS_scale_j_Total_EtaBin2]
+                - id: CMS_scale_j_Total_EtaBin3
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+                  parameters: [nu_CMS_scale_j_Total_EtaBin3]
+                - id: CMS_scale_j_Total_EtaBin4
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+                  parameters: [nu_CMS_scale_j_Total_EtaBin4]
+                - id: CMS_scale_j_Total_EtaBin5
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+                  parameters: [nu_CMS_scale_j_Total_EtaBin5]
+                - id: Uncl
+                  type: icph
+                  job: icph_TTLep_pow_2016_Uncl
+                  parameters: [nu_Uncl]
+
+jobs:
+  - id: ich_NG_PDF4LHC21_6_tt2l_delphes 
+    type: ich
+    region: SR_binned
+    process: tt2l_delphes
+    pdf:
+      #pdf_n: [1, 2, 4, 5, 10, 12]
+      #pdf_type: PODBasis
+      pdf_n: [1,2,3,4,5,6]
+      pdf_type: PODBasis
+      pdf_basis: gluon_POD_nongluon_PDF4LHC21 
+
+  - id: icph_TTLep_pow_2016_L1Prefire
+    type: icph
+    region: SR_binned
+    parameters: [nu_l1prefire]
+    combinations: [[nu_l1prefire]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["L1PreFiringWeight_Nom"] 
+        addweights: ["L1PreFiringWeight_Dn"] 
+      - coords: [ 0.0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [ 1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["L1PreFiringWeight_Nom"] 
+        addweights: ["L1PreFiringWeight_Up"] 
+  
+  - id: icph_TTLep_pow_2016_PU
+    type: icph
+    region: SR_binned
+    parameters: [nu_pu]
+    combinations: [[nu_pu]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["Pileup_SF"] 
+        addweights: ["Pileup_SFDn"] 
+      - coords: [ 0.0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [ 1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["Pileup_SF"] 
+        addweights: ["Pileup_SFUp"] 
+
+  - id: icph_TTLep_pow_2016_MuSF 
+    type: icph
+    region: SR_binned
+    parameters: [nu_MuSF]
+    combinations: [[nu_MuSF]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["lepMu_SF"] 
+        addweights: ["lepMu_SFDn"] 
+      - coords: [ 0.0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [ 1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["lepMu_SF"] 
+        addweights: ["lepMu_SFUp"] 
+
+  - id: icph_TTLep_pow_2016_EleSF 
+    type: icph
+    region: SR_binned
+    parameters: [nu_EleSF]
+    combinations: [[nu_EleSF]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["lepEle_SF"] 
+        addweights: ["lepEle_SFDn"] 
+      - coords: [ 0.0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [ 1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["lepEle_SF"] 
+        addweights: ["lepEle_SFUp"] 
+  
+  - id: icph_TTLep_pow_2016_BTag_b
+    type: icph
+    region: SR_binned
+    parameters: [nu_btag_b]
+    combinations: [[nu_btag_b]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["btagSF_fixedWP_SF"] 
+        addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFDn"] 
+      - coords: [ 0.0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [ 1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["btagSF_fixedWP_SF"] 
+        addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFUp"] 
+  
+  - id: icph_TTLep_pow_2016_BTag_l
+    type: icph
+    region: SR_binned
+    parameters: [nu_btag_l]
+    combinations: [[nu_btag_l]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["btagSF_fixedWP_SF"] 
+        addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFDn"] 
+      - coords: [ 0.0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [ 1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["btagSF_fixedWP_SF"] 
+        addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFUp"] 
+
+  - id: icph_TTLep_pow_2016_scales
+    type: icph
+    region: SR_binned
+    parameters: [nu_mu_ren, nu_mu_fac]
+    combinations: [[nu_mu_ren], [nu_mu_fac], [nu_mu_ren, nu_mu_ren], [nu_mu_ren, nu_mu_fac], [nu_mu_fac, nu_mu_fac]]
+    base_points:
+      - coords: [-1.0, -1.0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren0p5_fac0p5"]
+      - coords: [-1.0, 0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren0p5_fac1p0"]
+      - coords: [-1.0, 1.0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren0p5_fac2p0"]
+      - coords: [0, -1.0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren1p0_fac0p5"]
+      - coords: [0, 0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren1p0_fac1p0"]
+        nominal: true
+      - coords: [0, 1.0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren1p0_fac2p0"]
+      - coords: [1.0, -1.0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren2p0_fac0p5"]
+      - coords: [1.0, 0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren2p0_fac1p0"]
+      - coords: [1.0, 1.0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren2p0_fac2p0"]
+
+  - id: icph_TTLep_pow_2016_showerISR
+    type: icph
+    region: SR_binned
+    parameters: [nu_showerISR]
+    combinations: [[nu_showerISR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+
+  - id: icph_TTLep_pow_2016_showerFSR
+    type: icph
+    region: SR_binned
+    parameters: [nu_showerFSR]
+    combinations: [[nu_showerFSR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr1p0_fsr0p5"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr1p0_fsr2p0"]
+
+  - id: icph_TTLep_pow_2016_alphaS
+    type: icph
+    region: SR_binned
+    parameters: [nu_alphaS]
+    combinations: [[nu_alphaS]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_dn"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_up"]
+
+  - id: icph_TTLep_pow_2016_CMS_res_j_0_2016 
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_res_j_0]
+    combinations: [[nu_CMS_res_j_0]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_CMS_res_j_0_2016_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_CMS_res_j_0_2016_up
+
+  - id: icph_TTLep_pow_2016_CMS_res_j_1_2016 
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_res_j_1]
+    combinations: [[nu_CMS_res_j_1]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_CMS_res_j_1_2016_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_CMS_res_j_1_2016_up
+
+  - id: icph_TTLep_pow_2016_CMS_res_j_2_2016 
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_res_j_2]
+    combinations: [[nu_CMS_res_j_2]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_CMS_res_j_2_2016_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_CMS_res_j_2_2016_up
+
+  - id: icph_TTLep_pow_2016_CMS_res_j_3_2016 
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_res_j_3]
+    combinations: [[nu_CMS_res_j_3]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_CMS_res_j_3_2016_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_CMS_res_j_3_2016_up
+
+  - id: icph_TTLep_pow_2016_CMS_res_j_4_2016 
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_res_j_4]
+    combinations: [[nu_CMS_res_j_4]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_CMS_res_j_4_2016_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_CMS_res_j_4_2016_up
+
+  - id: icph_TTLep_pow_2016_CMS_res_j_5_2016 
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_res_j_5]
+    combinations: [[nu_CMS_res_j_5]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_CMS_res_j_5_2016_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_CMS_res_j_5_2016_up
+
+  # JES Eta-split bin 0
+  - id: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_scale_j_Total_EtaBin0]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_up
+
+  # JES Eta-split bin 1
+  - id: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_scale_j_Total_EtaBin1]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_up
+
+  # JES Eta-split bin 2
+  - id: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_scale_j_Total_EtaBin2]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_up
+
+  # JES Eta-split bin 3
+  - id: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_scale_j_Total_EtaBin3]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_up
+
+  # JES Eta-split bin 4
+  - id: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_scale_j_Total_EtaBin4]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_up
+
+  # JES Eta-split bin 5
+  - id: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_scale_j_Total_EtaBin5]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_up
+
+  - id: icph_TTLep_pow_2016_Uncl 
+    type: icph
+    region: SR_binned
+    parameters: [nu_Uncl]
+    combinations: [[nu_Uncl]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_Uncl_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_Uncl_up
+
diff --git a/configs/binned_v5D/binned_delphes_6_RunII.yaml b/configs/binned_v5D/binned_delphes_6_RunII.yaml
new file mode 100644
index 0000000..be52484
--- /dev/null
+++ b/configs/binned_v5D/binned_delphes_6_RunII.yaml
@@ -0,0 +1,507 @@
+version: binned_delphes_RunII_v5D
+
+defaults:
+  module_samples: "data.samples_RunII"
+  default_binning:
+    - ["tr_ttbar_mass", [300, 400, 500, 650, 1500]]
+    - ["tr_ttbar_y", [-2.5, -1.2, -0.8, -0.4, 0.4, 0.8, 1.2, 2.5]]
+        
+likelihood:
+    binned:
+        - id: SR 
+          classes: 
+            - id: tt2l_delphes 
+              sample: tt2l_delphes_RunII
+              POI:
+                job: ich_NG_PDF4LHC21_6_tt2l_delphes 
+                type: ich
+                parameters: [c0, c1, c2, c3, c4, c5]
+              systematics:
+                - id: lumi 
+                  type: lnN
+                  value: 0.0073
+                  parameters: [nu_lumi]
+                - id: L1Prefire
+                  type: icph
+                  job: icph_TTLep_pow_2016_L1Prefire
+                  parameters: [nu_l1prefire]
+                - id: PU
+                  type: icph
+                  job: icph_TTLep_pow_2016_PU
+                  parameters: [nu_pu]
+                - id: MuSF 
+                  type: icph
+                  job: icph_TTLep_pow_2016_MuSF
+                  parameters: [nu_MuSF]
+                - id: EleSF
+                  type: icph
+                  job: icph_TTLep_pow_2016_EleSF
+                  parameters: [nu_EleSF]
+                - id: BTag_b
+                  type: icph
+                  job: icph_TTLep_pow_2016_BTag_b
+                  parameters: [nu_btag_b]
+                - id: BTag_l
+                  type: icph
+                  job: icph_TTLep_pow_2016_BTag_l
+                  parameters: [nu_btag_l]
+                - id: Scales
+                  type: icph
+                  job: icph_TTLep_pow_2016_scales
+                  parameters: [nu_mu_ren, nu_mu_fac]
+                - id: ShowerISR
+                  type: icph
+                  job: icph_TTLep_pow_2016_showerISR
+                  parameters: [nu_showerISR]
+                - id: ShowerFSR
+                  type: icph
+                  job: icph_TTLep_pow_2016_showerFSR
+                  parameters: [nu_showerFSR]
+                - id: AlphaS
+                  type: icph
+                  job: icph_TTLep_pow_2016_alphaS
+                  parameters: [nu_alphaS]
+                - id: CMS_res_j_0
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_res_j_0_2016
+                  parameters: [nu_CMS_res_j_0]
+                - id: CMS_res_j_1
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_res_j_1_2016
+                  parameters: [nu_CMS_res_j_1]
+                - id: CMS_res_j_2
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_res_j_2_2016
+                  parameters: [nu_CMS_res_j_2]
+                - id: CMS_res_j_3
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_res_j_3_2016
+                  parameters: [nu_CMS_res_j_3]
+                - id: CMS_res_j_4
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_res_j_4_2016
+                  parameters: [nu_CMS_res_j_4]
+                - id: CMS_res_j_5
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_res_j_5_2016
+                  parameters: [nu_CMS_res_j_5]
+                - id: CMS_scale_j_Total_EtaBin0
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+                  parameters: [nu_CMS_scale_j_Total_EtaBin0]
+                - id: CMS_scale_j_Total_EtaBin1
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+                  parameters: [nu_CMS_scale_j_Total_EtaBin1]
+                - id: CMS_scale_j_Total_EtaBin2
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+                  parameters: [nu_CMS_scale_j_Total_EtaBin2]
+                - id: CMS_scale_j_Total_EtaBin3
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+                  parameters: [nu_CMS_scale_j_Total_EtaBin3]
+                - id: CMS_scale_j_Total_EtaBin4
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+                  parameters: [nu_CMS_scale_j_Total_EtaBin4]
+                - id: CMS_scale_j_Total_EtaBin5
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+                  parameters: [nu_CMS_scale_j_Total_EtaBin5]
+                - id: Uncl
+                  type: icph
+                  job: icph_TTLep_pow_2016_Uncl
+                  parameters: [nu_Uncl]
+
+jobs:
+  - id: ich_NG_PDF4LHC21_6_tt2l_delphes 
+    type: ich
+    region: SR_binned
+    process: tt2l_delphes_RunII
+    pdf:
+      #pdf_n: [1, 2, 4, 5, 10, 12]
+      #pdf_type: PODBasis
+      pdf_n: [1,2,3,4,5,6]
+      pdf_type: PODBasis
+      pdf_basis: gluon_POD_nongluon_PDF4LHC21 
+
+  - id: icph_TTLep_pow_2016_L1Prefire
+    type: icph
+    region: SR_binned
+    parameters: [nu_l1prefire]
+    combinations: [[nu_l1prefire]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["L1PreFiringWeight_Nom"] 
+        addweights: ["L1PreFiringWeight_Dn"] 
+      - coords: [ 0.0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [ 1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["L1PreFiringWeight_Nom"] 
+        addweights: ["L1PreFiringWeight_Up"] 
+  
+  - id: icph_TTLep_pow_2016_PU
+    type: icph
+    region: SR_binned
+    parameters: [nu_pu]
+    combinations: [[nu_pu]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["Pileup_SF"] 
+        addweights: ["Pileup_SFDn"] 
+      - coords: [ 0.0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [ 1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["Pileup_SF"] 
+        addweights: ["Pileup_SFUp"] 
+
+  - id: icph_TTLep_pow_2016_MuSF 
+    type: icph
+    region: SR_binned
+    parameters: [nu_MuSF]
+    combinations: [[nu_MuSF]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["lepMu_SF"] 
+        addweights: ["lepMu_SFDn"] 
+      - coords: [ 0.0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [ 1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["lepMu_SF"] 
+        addweights: ["lepMu_SFUp"] 
+
+  - id: icph_TTLep_pow_2016_EleSF 
+    type: icph
+    region: SR_binned
+    parameters: [nu_EleSF]
+    combinations: [[nu_EleSF]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["lepEle_SF"] 
+        addweights: ["lepEle_SFDn"] 
+      - coords: [ 0.0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [ 1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["lepEle_SF"] 
+        addweights: ["lepEle_SFUp"] 
+  
+  - id: icph_TTLep_pow_2016_BTag_b
+    type: icph
+    region: SR_binned
+    parameters: [nu_btag_b]
+    combinations: [[nu_btag_b]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["btagSF_fixedWP_SF"] 
+        addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFDn"] 
+      - coords: [ 0.0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [ 1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["btagSF_fixedWP_SF"] 
+        addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFUp"] 
+  
+  - id: icph_TTLep_pow_2016_BTag_l
+    type: icph
+    region: SR_binned
+    parameters: [nu_btag_l]
+    combinations: [[nu_btag_l]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["btagSF_fixedWP_SF"] 
+        addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFDn"] 
+      - coords: [ 0.0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [ 1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["btagSF_fixedWP_SF"] 
+        addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFUp"] 
+
+  - id: icph_TTLep_pow_2016_scales
+    type: icph
+    region: SR_binned
+    parameters: [nu_mu_ren, nu_mu_fac]
+    combinations: [[nu_mu_ren], [nu_mu_fac], [nu_mu_ren, nu_mu_ren], [nu_mu_ren, nu_mu_fac], [nu_mu_fac, nu_mu_fac]]
+    base_points:
+      - coords: [-1.0, -1.0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren0p5_fac0p5"]
+      - coords: [-1.0, 0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren0p5_fac1p0"]
+      - coords: [-1.0, 1.0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren0p5_fac2p0"]
+      - coords: [0, -1.0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren1p0_fac0p5"]
+      - coords: [0, 0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren1p0_fac1p0"]
+        nominal: true
+      - coords: [0, 1.0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren1p0_fac2p0"]
+      - coords: [1.0, -1.0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren2p0_fac0p5"]
+      - coords: [1.0, 0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren2p0_fac1p0"]
+      - coords: [1.0, 1.0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren2p0_fac2p0"]
+
+  - id: icph_TTLep_pow_2016_showerISR
+    type: icph
+    region: SR_binned
+    parameters: [nu_showerISR]
+    combinations: [[nu_showerISR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+
+  - id: icph_TTLep_pow_2016_showerFSR
+    type: icph
+    region: SR_binned
+    parameters: [nu_showerFSR]
+    combinations: [[nu_showerFSR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr1p0_fsr0p5"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr1p0_fsr2p0"]
+
+  - id: icph_TTLep_pow_2016_alphaS
+    type: icph
+    region: SR_binned
+    parameters: [nu_alphaS]
+    combinations: [[nu_alphaS]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_dn"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_up"]
+
+  - id: icph_TTLep_pow_2016_CMS_res_j_0_2016 
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_res_j_0]
+    combinations: [[nu_CMS_res_j_0]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_CMS_res_j_0_2016_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_CMS_res_j_0_2016_up
+
+  - id: icph_TTLep_pow_2016_CMS_res_j_1_2016 
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_res_j_1]
+    combinations: [[nu_CMS_res_j_1]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_CMS_res_j_1_2016_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_CMS_res_j_1_2016_up
+
+  - id: icph_TTLep_pow_2016_CMS_res_j_2_2016 
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_res_j_2]
+    combinations: [[nu_CMS_res_j_2]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_CMS_res_j_2_2016_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_CMS_res_j_2_2016_up
+
+  - id: icph_TTLep_pow_2016_CMS_res_j_3_2016 
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_res_j_3]
+    combinations: [[nu_CMS_res_j_3]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_CMS_res_j_3_2016_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_CMS_res_j_3_2016_up
+
+  - id: icph_TTLep_pow_2016_CMS_res_j_4_2016 
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_res_j_4]
+    combinations: [[nu_CMS_res_j_4]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_CMS_res_j_4_2016_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_CMS_res_j_4_2016_up
+
+  - id: icph_TTLep_pow_2016_CMS_res_j_5_2016 
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_res_j_5]
+    combinations: [[nu_CMS_res_j_5]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_CMS_res_j_5_2016_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_CMS_res_j_5_2016_up
+
+  # JES Eta-split bin 0
+  - id: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_scale_j_Total_EtaBin0]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_up
+
+  # JES Eta-split bin 1
+  - id: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_scale_j_Total_EtaBin1]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_up
+
+  # JES Eta-split bin 2
+  - id: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_scale_j_Total_EtaBin2]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_up
+
+  # JES Eta-split bin 3
+  - id: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_scale_j_Total_EtaBin3]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_up
+
+  # JES Eta-split bin 4
+  - id: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_scale_j_Total_EtaBin4]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_up
+
+  # JES Eta-split bin 5
+  - id: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_scale_j_Total_EtaBin5]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_up
+
+  - id: icph_TTLep_pow_2016_Uncl 
+    type: icph
+    region: SR_binned
+    parameters: [nu_Uncl]
+    combinations: [[nu_Uncl]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_Uncl_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_Uncl_up
+
diff --git a/configs/binned_v5D/binned_delphes_7_RunII.yaml b/configs/binned_v5D/binned_delphes_7_RunII.yaml
new file mode 100644
index 0000000..759755b
--- /dev/null
+++ b/configs/binned_v5D/binned_delphes_7_RunII.yaml
@@ -0,0 +1,507 @@
+version: binned_delphes_RunII_v5D
+
+defaults:
+  module_samples: "data.samples_RunII"
+  default_binning:
+    - ["tr_ttbar_mass", [300, 400, 500, 650, 1500]]
+    - ["tr_ttbar_y", [-2.5, -1.2, -0.8, -0.4, 0.4, 0.8, 1.2, 2.5]]
+        
+likelihood:
+    binned:
+        - id: SR 
+          classes: 
+            - id: tt2l_delphes 
+              sample: tt2l_delphes_RunII
+              POI:
+                job: ich_NG_PDF4LHC21_7_tt2l_delphes 
+                type: ich
+                parameters: [c0, c1, c2, c3, c4, c5, c6]
+              systematics:
+                - id: lumi 
+                  type: lnN
+                  value: 0.0073
+                  parameters: [nu_lumi]
+                - id: L1Prefire
+                  type: icph
+                  job: icph_TTLep_pow_2016_L1Prefire
+                  parameters: [nu_l1prefire]
+                - id: PU
+                  type: icph
+                  job: icph_TTLep_pow_2016_PU
+                  parameters: [nu_pu]
+                - id: MuSF 
+                  type: icph
+                  job: icph_TTLep_pow_2016_MuSF
+                  parameters: [nu_MuSF]
+                - id: EleSF
+                  type: icph
+                  job: icph_TTLep_pow_2016_EleSF
+                  parameters: [nu_EleSF]
+                - id: BTag_b
+                  type: icph
+                  job: icph_TTLep_pow_2016_BTag_b
+                  parameters: [nu_btag_b]
+                - id: BTag_l
+                  type: icph
+                  job: icph_TTLep_pow_2016_BTag_l
+                  parameters: [nu_btag_l]
+                - id: Scales
+                  type: icph
+                  job: icph_TTLep_pow_2016_scales
+                  parameters: [nu_mu_ren, nu_mu_fac]
+                - id: ShowerISR
+                  type: icph
+                  job: icph_TTLep_pow_2016_showerISR
+                  parameters: [nu_showerISR]
+                - id: ShowerFSR
+                  type: icph
+                  job: icph_TTLep_pow_2016_showerFSR
+                  parameters: [nu_showerFSR]
+                - id: AlphaS
+                  type: icph
+                  job: icph_TTLep_pow_2016_alphaS
+                  parameters: [nu_alphaS]
+                - id: CMS_res_j_0
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_res_j_0_2016
+                  parameters: [nu_CMS_res_j_0]
+                - id: CMS_res_j_1
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_res_j_1_2016
+                  parameters: [nu_CMS_res_j_1]
+                - id: CMS_res_j_2
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_res_j_2_2016
+                  parameters: [nu_CMS_res_j_2]
+                - id: CMS_res_j_3
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_res_j_3_2016
+                  parameters: [nu_CMS_res_j_3]
+                - id: CMS_res_j_4
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_res_j_4_2016
+                  parameters: [nu_CMS_res_j_4]
+                - id: CMS_res_j_5
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_res_j_5_2016
+                  parameters: [nu_CMS_res_j_5]
+                - id: CMS_scale_j_Total_EtaBin0
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+                  parameters: [nu_CMS_scale_j_Total_EtaBin0]
+                - id: CMS_scale_j_Total_EtaBin1
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+                  parameters: [nu_CMS_scale_j_Total_EtaBin1]
+                - id: CMS_scale_j_Total_EtaBin2
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+                  parameters: [nu_CMS_scale_j_Total_EtaBin2]
+                - id: CMS_scale_j_Total_EtaBin3
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+                  parameters: [nu_CMS_scale_j_Total_EtaBin3]
+                - id: CMS_scale_j_Total_EtaBin4
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+                  parameters: [nu_CMS_scale_j_Total_EtaBin4]
+                - id: CMS_scale_j_Total_EtaBin5
+                  type: icph
+                  job: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+                  parameters: [nu_CMS_scale_j_Total_EtaBin5]
+                - id: Uncl
+                  type: icph
+                  job: icph_TTLep_pow_2016_Uncl
+                  parameters: [nu_Uncl]
+
+jobs:
+  - id: ich_NG_PDF4LHC21_7_tt2l_delphes 
+    type: ich
+    region: SR_binned
+    process: tt2l_delphes_RunII
+    pdf:
+      #pdf_n: [1, 2, 4, 5, 10, 12]
+      #pdf_type: PODBasis
+      pdf_n: [1,2,3,4,5,6,7]
+      pdf_type: PODBasis
+      pdf_basis: gluon_POD_nongluon_PDF4LHC21 
+
+  - id: icph_TTLep_pow_2016_L1Prefire
+    type: icph
+    region: SR_binned
+    parameters: [nu_l1prefire]
+    combinations: [[nu_l1prefire]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["L1PreFiringWeight_Nom"] 
+        addweights: ["L1PreFiringWeight_Dn"] 
+      - coords: [ 0.0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [ 1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["L1PreFiringWeight_Nom"] 
+        addweights: ["L1PreFiringWeight_Up"] 
+  
+  - id: icph_TTLep_pow_2016_PU
+    type: icph
+    region: SR_binned
+    parameters: [nu_pu]
+    combinations: [[nu_pu]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["Pileup_SF"] 
+        addweights: ["Pileup_SFDn"] 
+      - coords: [ 0.0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [ 1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["Pileup_SF"] 
+        addweights: ["Pileup_SFUp"] 
+
+  - id: icph_TTLep_pow_2016_MuSF 
+    type: icph
+    region: SR_binned
+    parameters: [nu_MuSF]
+    combinations: [[nu_MuSF]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["lepMu_SF"] 
+        addweights: ["lepMu_SFDn"] 
+      - coords: [ 0.0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [ 1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["lepMu_SF"] 
+        addweights: ["lepMu_SFUp"] 
+
+  - id: icph_TTLep_pow_2016_EleSF 
+    type: icph
+    region: SR_binned
+    parameters: [nu_EleSF]
+    combinations: [[nu_EleSF]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["lepEle_SF"] 
+        addweights: ["lepEle_SFDn"] 
+      - coords: [ 0.0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [ 1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["lepEle_SF"] 
+        addweights: ["lepEle_SFUp"] 
+  
+  - id: icph_TTLep_pow_2016_BTag_b
+    type: icph
+    region: SR_binned
+    parameters: [nu_btag_b]
+    combinations: [[nu_btag_b]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["btagSF_fixedWP_SF"] 
+        addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFDn"] 
+      - coords: [ 0.0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [ 1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["btagSF_fixedWP_SF"] 
+        addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFUp"] 
+  
+  - id: icph_TTLep_pow_2016_BTag_l
+    type: icph
+    region: SR_binned
+    parameters: [nu_btag_l]
+    combinations: [[nu_btag_l]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["btagSF_fixedWP_SF"] 
+        addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFDn"] 
+      - coords: [ 0.0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [ 1.0]
+        loader: TTLep_pow_2016
+        removeweights: ["btagSF_fixedWP_SF"] 
+        addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFUp"] 
+
+  - id: icph_TTLep_pow_2016_scales
+    type: icph
+    region: SR_binned
+    parameters: [nu_mu_ren, nu_mu_fac]
+    combinations: [[nu_mu_ren], [nu_mu_fac], [nu_mu_ren, nu_mu_ren], [nu_mu_ren, nu_mu_fac], [nu_mu_fac, nu_mu_fac]]
+    base_points:
+      - coords: [-1.0, -1.0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren0p5_fac0p5"]
+      - coords: [-1.0, 0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren0p5_fac1p0"]
+      - coords: [-1.0, 1.0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren0p5_fac2p0"]
+      - coords: [0, -1.0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren1p0_fac0p5"]
+      - coords: [0, 0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren1p0_fac1p0"]
+        nominal: true
+      - coords: [0, 1.0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren1p0_fac2p0"]
+      - coords: [1.0, -1.0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren2p0_fac0p5"]
+      - coords: [1.0, 0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren2p0_fac1p0"]
+      - coords: [1.0, 1.0]
+        loader: TTLep_pow_2016
+        addweights: ["scale_ren2p0_fac2p0"]
+
+  - id: icph_TTLep_pow_2016_showerISR
+    type: icph
+    region: SR_binned
+    parameters: [nu_showerISR]
+    combinations: [[nu_showerISR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+
+  - id: icph_TTLep_pow_2016_showerFSR
+    type: icph
+    region: SR_binned
+    parameters: [nu_showerFSR]
+    combinations: [[nu_showerFSR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr1p0_fsr0p5"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr1p0_fsr2p0"]
+
+  - id: icph_TTLep_pow_2016_alphaS
+    type: icph
+    region: SR_binned
+    parameters: [nu_alphaS]
+    combinations: [[nu_alphaS]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_dn"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_up"]
+
+  - id: icph_TTLep_pow_2016_CMS_res_j_0_2016 
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_res_j_0]
+    combinations: [[nu_CMS_res_j_0]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_CMS_res_j_0_2016_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_CMS_res_j_0_2016_up
+
+  - id: icph_TTLep_pow_2016_CMS_res_j_1_2016 
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_res_j_1]
+    combinations: [[nu_CMS_res_j_1]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_CMS_res_j_1_2016_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_CMS_res_j_1_2016_up
+
+  - id: icph_TTLep_pow_2016_CMS_res_j_2_2016 
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_res_j_2]
+    combinations: [[nu_CMS_res_j_2]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_CMS_res_j_2_2016_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_CMS_res_j_2_2016_up
+
+  - id: icph_TTLep_pow_2016_CMS_res_j_3_2016 
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_res_j_3]
+    combinations: [[nu_CMS_res_j_3]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_CMS_res_j_3_2016_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_CMS_res_j_3_2016_up
+
+  - id: icph_TTLep_pow_2016_CMS_res_j_4_2016 
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_res_j_4]
+    combinations: [[nu_CMS_res_j_4]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_CMS_res_j_4_2016_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_CMS_res_j_4_2016_up
+
+  - id: icph_TTLep_pow_2016_CMS_res_j_5_2016 
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_res_j_5]
+    combinations: [[nu_CMS_res_j_5]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_CMS_res_j_5_2016_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_CMS_res_j_5_2016_up
+
+  # JES Eta-split bin 0
+  - id: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_scale_j_Total_EtaBin0]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_up
+
+  # JES Eta-split bin 1
+  - id: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_scale_j_Total_EtaBin1]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_up
+
+  # JES Eta-split bin 2
+  - id: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_scale_j_Total_EtaBin2]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_up
+
+  # JES Eta-split bin 3
+  - id: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_scale_j_Total_EtaBin3]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_up
+
+  # JES Eta-split bin 4
+  - id: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_scale_j_Total_EtaBin4]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_up
+
+  # JES Eta-split bin 5
+  - id: icph_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+    type: icph
+    region: SR_binned
+    parameters: [nu_CMS_scale_j_Total_EtaBin5]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_up
+
+  - id: icph_TTLep_pow_2016_Uncl 
+    type: icph
+    region: SR_binned
+    parameters: [nu_Uncl]
+    combinations: [[nu_Uncl]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016_Uncl_down 
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016_Uncl_up
+
diff --git a/configs/binned_v6/binned_2016.yaml b/configs/binned_v6/binned_2016.yaml
index 313c510..521788f 100644
--- a/configs/binned_v6/binned_2016.yaml
+++ b/configs/binned_v6/binned_2016.yaml
@@ -17,6 +17,18 @@ likelihood:
                 type: ich
                 parameters: [c0, c1, c2, c3, c4, c5]
               systematics:
+                - id: Lumi_1516
+                  type: lnN
+                  value: 0.0118
+                  parameters: [nu_lumi_1516]
+                - id: Lumi_151617
+                  type: lnN
+                  value: 0.0004
+                  parameters: [nu_lumi_151617]
+                - id: Lumi_15161718
+                  type: lnN
+                  value: 0.0035
+                  parameters: [nu_lumi_15161718]
                 - id: L1Prefire
                   type: icph
                   job: icph_TTLep_pow_2016_L1Prefire
diff --git a/configs/binned_v6/binned_2016APV.yaml b/configs/binned_v6/binned_2016APV.yaml
index db3eda1..875061e 100644
--- a/configs/binned_v6/binned_2016APV.yaml
+++ b/configs/binned_v6/binned_2016APV.yaml
@@ -17,6 +17,18 @@ likelihood:
                 type: ich
                 parameters: [c0, c1, c2, c3, c4, c5]
               systematics:
+                - id: Lumi_1516
+                  type: lnN
+                  value: 0.0118
+                  parameters: [nu_lumi_1516]
+                - id: Lumi_151617
+                  type: lnN
+                  value: 0.0004
+                  parameters: [nu_lumi_151617]
+                - id: Lumi_15161718
+                  type: lnN
+                  value: 0.0035
+                  parameters: [nu_lumi_15161718]
                 - id: L1Prefire
                   type: icph
                   job: icph_TTLep_pow_2016APV_L1Prefire
diff --git a/configs/binned_v6/binned_2017.yaml b/configs/binned_v6/binned_2017.yaml
index da7d686..c3c81fe 100644
--- a/configs/binned_v6/binned_2017.yaml
+++ b/configs/binned_v6/binned_2017.yaml
@@ -17,6 +17,14 @@ likelihood:
                 type: ich
                 parameters: [c0, c1, c2, c3, c4, c5]
               systematics:
+                - id: Lumi_151617
+                  type: lnN
+                  value: 0.0055
+                  parameters: [nu_lumi_151617]
+                - id: Lumi_15161718
+                  type: lnN
+                  value: 0.0061
+                  parameters: [nu_lumi_15161718]                   
                 - id: L1Prefire
                   type: icph
                   job: icph_TTLep_pow_2017_L1Prefire
diff --git a/configs/binned_v6/binned_2018.yaml b/configs/binned_v6/binned_2018.yaml
index e5340ff..c9417bb 100644
--- a/configs/binned_v6/binned_2018.yaml
+++ b/configs/binned_v6/binned_2018.yaml
@@ -17,6 +17,10 @@ likelihood:
                 type: ich
                 parameters: [c0, c1, c2, c3, c4, c5]
               systematics:
+                - id: Lumi_15161718
+                  type: lnN
+                  value: 0.0084
+                  parameters: [nu_lumi_15161718]
                 - id: L1Prefire
                   type: icph
                   job: icph_TTLep_pow_2018_L1Prefire
diff --git a/configs/unbinned_v5D/unbinned_delphes_1.yaml b/configs/unbinned_v5D/unbinned_delphes_1.yaml
new file mode 100644
index 0000000..86d927e
--- /dev/null
+++ b/configs/unbinned_v5D/unbinned_delphes_1.yaml
@@ -0,0 +1,1384 @@
+version: unbinned_v5D
+
+defaults:
+  module_samples: "data.samples_RunII"
+  default_features:
+    - TOP_KINEMATICS
+    - LEPTON_KINEMATICS
+    - ASYMMETRY
+
+  splitting:
+    enabled: true
+    uid_fields: ["run", "luminosityBlock", "event"]
+    seed: 42
+    n_buckets: 10000 
+
+    scheme:
+      pnn_train:     { fraction: 0.50 }
+      pnn_val:       { fraction: 0.10 }
+      c2st_train:    { fraction: 0.15 }
+      c2st_val:      { fraction: 0.05 }
+      final_eval:    { fraction: 0.20 }
+
+  early_stopping:
+    enabled: true
+    patience: 20        # same as current hard-coded
+    min_delta: 0.0      # improvement threshold; keep 0.0 to match current behavior
+    mode: "min"         # val_loss should decrease
+    warmup_epochs: 0    # optional: do not early-stop before this epoch
+
+
+likelihood:
+    regions:
+        - id: SR 
+          classifier:
+            type: null
+            id: null    # no classifier needed for a single process
+            asimov: [tt2l_delphes]
+          classes: 
+            - id: tt2l_delphes
+              sample: tt2l_delphes
+              POI:
+                job: bit_NG_PDF4LHC21_1_tt2l_delphes 
+                type: bit
+                parameters: [c0]
+              systematics:
+                - id: L1Prefire
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_L1Prefire
+                  parameters: [nu_l1prefire]
+                - id: PU
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_PU
+                  parameters: [nu_pu]
+                - id: MuSF 
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_MuSF
+                  parameters: [nu_MuSF]
+                - id: EleSF
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_EleSF
+                  parameters: [nu_EleSF]
+                - id: BTag_b
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_BTag_b
+                  parameters: [nu_btag_b]
+                - id: BTag_l
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_BTag_l
+                  parameters: [nu_btag_l]
+                - id: Scales
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_scales
+                  parameters: [nu_mu_ren, nu_mu_fac]
+                - id: ShowerISR
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_showerISR
+                  parameters: [nu_showerISR]
+                - id: ShowerFSR
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_showerFSR
+                  parameters: [nu_showerFSR]
+                - id: AlphaS
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_alphaS
+                  parameters: [nu_alphaS]
+                - id: CMS_res_j_0
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_0_2016
+                  parameters: [nu_CMS_res_j_0]
+                - id: CMS_res_j_1
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_1_2016
+                  parameters: [nu_CMS_res_j_1]
+                - id: CMS_res_j_2
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_2_2016
+                  parameters: [nu_CMS_res_j_2]
+                - id: CMS_res_j_3
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_3_2016
+                  parameters: [nu_CMS_res_j_3]
+                - id: CMS_res_j_4
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_4_2016
+                  parameters: [nu_CMS_res_j_4]
+                - id: CMS_res_j_5
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_5_2016
+                  parameters: [nu_CMS_res_j_5]
+                - id: CMS_scale_j_Total_EtaBin0
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+                  parameters: [nu_CMS_scale_j_Total_EtaBin0]
+                - id: CMS_scale_j_Total_EtaBin1
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+                  parameters: [nu_CMS_scale_j_Total_EtaBin1]
+                - id: CMS_scale_j_Total_EtaBin2
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+                  parameters: [nu_CMS_scale_j_Total_EtaBin2]
+                - id: CMS_scale_j_Total_EtaBin3
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+                  parameters: [nu_CMS_scale_j_Total_EtaBin3]
+                - id: CMS_scale_j_Total_EtaBin4
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+                  parameters: [nu_CMS_scale_j_Total_EtaBin4]
+                - id: CMS_scale_j_Total_EtaBin5
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+                  parameters: [nu_CMS_scale_j_Total_EtaBin5]
+                - id: Uncl
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_Uncl
+                  parameters: [nu_Uncl]
+
+
+jobs:
+  - id: bit_NG_PDF4LHC21_1_tt2l_delphes
+    type: bit
+    region: SR
+    process: tt2l_delphes
+    selection: null               # optional extra selection layered on top
+    numba: True
+    pdf:
+      pdf_n: [1]
+      pdf_type: PODBasis
+      pdf_basis: gluon_POD_nongluon_PDF4LHC21 
+    model:
+      n_trees: 200
+      learning_rate: 0.2
+      loss: MSE                   # or "CrossEntropy"
+      learn_global_score: true
+      split_mode: "binned"
+      n_bins: 256
+      quantile_bins: true  # if True: quantile edges; else uniform edges
+    runtime:
+      training_plots: true        # keep if you want training plots
+    output:
+      filename: "BIT_NG_PDF4LHC21_1_tt2l_delphes.pkl"
+
+  - id: scaler_TTLep_pow_2016
+    type: scaler
+    process: TTLep_pow_2016
+    region: SR
+    selection: null
+    output:
+      filename: "Scaler_TTLep_pow_2016.pkl"
+
+  - id: icp_TTLep_pow_2016_L1Prefire
+    type: icp
+    region: SR
+    parameters: [nu_l1prefire]
+    combinations: [[nu_l1prefire]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Dn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Up"]
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_L1Prefire.pkl
+  - id: pnn_TTLep_pow_2016_L1Prefire
+    type: pnn
+    region: SR
+    parameters: [nu_l1prefire]
+    combinations: [[nu_l1prefire]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Dn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Up"]
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_L1Prefire
+
+  - id: icp_TTLep_pow_2016_PU
+    type: icp
+    region: SR
+    parameters: [nu_pu]
+    combinations: [[nu_pu]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFUp"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_PU.pkl
+
+  - id: pnn_TTLep_pow_2016_PU
+    type: pnn
+    region: SR
+    parameters: [nu_pu]
+    combinations: [[nu_pu]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFUp"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_PU
+
+  - id: icp_TTLep_pow_2016_MuSF
+    type: icp
+    region: SR
+    parameters: [nu_MuSF]
+    combinations: [[nu_MuSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFUp"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_MuSF.pkl
+  - id: pnn_TTLep_pow_2016_MuSF
+    type: pnn
+    region: SR
+    parameters: [nu_MuSF]
+    combinations: [[nu_MuSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFUp"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_MuSF
+  - id: icp_TTLep_pow_2016_EleSF
+    type: icp
+    region: SR
+    parameters: [nu_EleSF]
+    combinations: [[nu_EleSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFUp"]
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_EleSF.pkl
+  - id: pnn_TTLep_pow_2016_EleSF
+    type: pnn
+    region: SR
+    parameters: [nu_EleSF]
+    combinations: [[nu_EleSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFUp"]
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_EleSF
+  - id: icp_TTLep_pow_2016_BTag_b
+    type: icp
+    region: SR
+    parameters: [nu_btag_b]
+    combinations: [[nu_btag_b]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFUp"]
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_BTag_b.pkl
+  - id: pnn_TTLep_pow_2016_BTag_b
+    type: pnn
+    region: SR
+    parameters: [nu_btag_b]
+    combinations: [[nu_btag_b]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFUp"]
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_BTag_b
+  - id: icp_TTLep_pow_2016_BTag_l
+    type: icp
+    region: SR
+    parameters: [nu_btag_l]
+    combinations: [[nu_btag_l]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFUp"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_BTag_l.pkl
+  - id: pnn_TTLep_pow_2016_BTag_l
+    type: pnn
+    region: SR
+    parameters: [nu_btag_l]
+    combinations: [[nu_btag_l]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFUp"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_BTag_l
+
+  - id: icp_TTLep_pow_2016_scales
+    type: icp
+    region: SR
+    parameters: [nu_mu_ren, nu_mu_fac]
+    combinations: [[nu_mu_ren], [nu_mu_fac], [nu_mu_ren, nu_mu_ren], [nu_mu_ren, 
+          nu_mu_fac], [nu_mu_fac, nu_mu_fac]]
+    base_points:
+    - coords: [-1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac0p5"]
+    - coords: [-1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac1p0"]
+    - coords: [-1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac2p0"]
+    - coords: [0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac0p5"]
+    - coords: [0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac1p0"]
+      nominal: true
+    - coords: [0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac2p0"]
+    - coords: [1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac0p5"]
+    - coords: [1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac1p0"]
+    - coords: [1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac2p0"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_scales.pkl
+
+  - id: pnn_TTLep_pow_2016_scales
+    type: pnn
+    region: SR
+    parameters: [nu_mu_ren, nu_mu_fac]
+    combinations: [[nu_mu_ren], [nu_mu_fac], [nu_mu_ren, nu_mu_ren], [nu_mu_ren, 
+          nu_mu_fac], [nu_mu_fac, nu_mu_fac]]
+    base_points:
+    - coords: [-1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac0p5"]
+    - coords: [-1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac1p0"]
+    - coords: [-1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac2p0"]
+    - coords: [0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac0p5"]
+    - coords: [0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac1p0"]
+      nominal: true
+    - coords: [0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac2p0"]
+    - coords: [1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac0p5"]
+    - coords: [1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac1p0"]
+    - coords: [1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac2p0"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_scales
+
+  - id: icp_TTLep_pow_2016_showerISR
+    type: icp
+    region: SR
+    parameters: [nu_showerISR]
+    combinations: [[nu_showerISR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_showerISR.pkl
+
+  - id: pnn_TTLep_pow_2016_showerISR
+    type: pnn
+    region: SR
+    parameters: [nu_showerISR]
+    combinations: [[nu_showerISR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_showerISR
+
+  - id: icp_TTLep_pow_2016_showerFSR
+    type: icp
+    region: SR
+    parameters: [nu_showerFSR]
+    combinations: [[nu_showerFSR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_showerFSR.pkl
+
+  - id: pnn_TTLep_pow_2016_showerFSR
+    type: pnn
+    region: SR
+    parameters: [nu_showerFSR]
+    combinations: [[nu_showerFSR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_showerFSR
+
+  - id: icp_TTLep_pow_2016_alphaS
+    type: icp
+    region: SR
+    parameters: [nu_alphaS]
+    combinations: [[nu_alphaS]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_dn"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_up"]
+ 
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_alphaS.pkl
+
+  - id: pnn_TTLep_pow_2016_alphaS
+    type: pnn
+    region: SR
+    parameters: [nu_alphaS]
+    combinations: [[nu_alphaS]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_dn"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_up"]
+ 
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_alphaS
+
+  - id: icp_TTLep_pow_2016_CMS_res_j_0_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_0]
+    combinations: [[nu_CMS_res_j_0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_0_2016.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_res_j_0_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_0]
+    combinations: [[nu_CMS_res_j_0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_0_2016
+
+  - id: icp_TTLep_pow_2016_CMS_res_j_1_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_1]
+    combinations: [[nu_CMS_res_j_1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_1_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_1_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_1]
+    combinations: [[nu_CMS_res_j_1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_1_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_2_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_2]
+    combinations: [[nu_CMS_res_j_2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_2_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_2_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_2]
+    combinations: [[nu_CMS_res_j_2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_2_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_3_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_3]
+    combinations: [[nu_CMS_res_j_3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_3_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_3_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_3]
+    combinations: [[nu_CMS_res_j_3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_3_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_4_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_4]
+    combinations: [[nu_CMS_res_j_4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_4_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_4_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_4]
+    combinations: [[nu_CMS_res_j_4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_4_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_5_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_5]
+    combinations: [[nu_CMS_res_j_5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_5_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_5_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_5]
+    combinations: [[nu_CMS_res_j_5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_5_2016
+
+  # JES Eta-split bin 0
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin0]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin0]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+
+  # JES Eta-split bin 1
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin1]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin1]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+
+  # JES Eta-split bin 2
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin2]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin2]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+
+  # JES Eta-split bin 3
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin3]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin3]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+
+  # JES Eta-split bin 4
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin4]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin4]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+
+  # JES Eta-split bin 5
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin5]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin5]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+
+  - id: icp_TTLep_pow_2016_Uncl
+    type: icp
+    region: SR
+    parameters: [nu_Uncl]
+    combinations: [[nu_Uncl]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_Uncl_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_Uncl_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_Uncl.pkl
+  - id: pnn_TTLep_pow_2016_Uncl
+    type: pnn
+    region: SR
+    parameters: [nu_Uncl]
+    combinations: [[nu_Uncl]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_Uncl_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_Uncl_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_Uncl
+
diff --git a/configs/unbinned_v5D/unbinned_delphes_2.yaml b/configs/unbinned_v5D/unbinned_delphes_2.yaml
new file mode 100644
index 0000000..00f71fc
--- /dev/null
+++ b/configs/unbinned_v5D/unbinned_delphes_2.yaml
@@ -0,0 +1,1384 @@
+version: unbinned_v5D
+
+defaults:
+  module_samples: "data.samples_RunII"
+  default_features:
+    - TOP_KINEMATICS
+    - LEPTON_KINEMATICS
+    - ASYMMETRY
+
+  splitting:
+    enabled: true
+    uid_fields: ["run", "luminosityBlock", "event"]
+    seed: 42
+    n_buckets: 10000 
+
+    scheme:
+      pnn_train:     { fraction: 0.50 }
+      pnn_val:       { fraction: 0.10 }
+      c2st_train:    { fraction: 0.15 }
+      c2st_val:      { fraction: 0.05 }
+      final_eval:    { fraction: 0.20 }
+
+  early_stopping:
+    enabled: true
+    patience: 20        # same as current hard-coded
+    min_delta: 0.0      # improvement threshold; keep 0.0 to match current behavior
+    mode: "min"         # val_loss should decrease
+    warmup_epochs: 0    # optional: do not early-stop before this epoch
+
+
+likelihood:
+    regions:
+        - id: SR 
+          classifier:
+            type: null
+            id: null    # no classifier needed for a single process
+            asimov: [tt2l_delphes]
+          classes: 
+            - id: tt2l_delphes
+              sample: tt2l_delphes
+              POI:
+                job: bit_NG_PDF4LHC21_2_tt2l_delphes 
+                type: bit
+                parameters: [c0, c1]
+              systematics:
+                - id: L1Prefire
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_L1Prefire
+                  parameters: [nu_l1prefire]
+                - id: PU
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_PU
+                  parameters: [nu_pu]
+                - id: MuSF 
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_MuSF
+                  parameters: [nu_MuSF]
+                - id: EleSF
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_EleSF
+                  parameters: [nu_EleSF]
+                - id: BTag_b
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_BTag_b
+                  parameters: [nu_btag_b]
+                - id: BTag_l
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_BTag_l
+                  parameters: [nu_btag_l]
+                - id: Scales
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_scales
+                  parameters: [nu_mu_ren, nu_mu_fac]
+                - id: ShowerISR
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_showerISR
+                  parameters: [nu_showerISR]
+                - id: ShowerFSR
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_showerFSR
+                  parameters: [nu_showerFSR]
+                - id: AlphaS
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_alphaS
+                  parameters: [nu_alphaS]
+                - id: CMS_res_j_0
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_0_2016
+                  parameters: [nu_CMS_res_j_0]
+                - id: CMS_res_j_1
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_1_2016
+                  parameters: [nu_CMS_res_j_1]
+                - id: CMS_res_j_2
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_2_2016
+                  parameters: [nu_CMS_res_j_2]
+                - id: CMS_res_j_3
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_3_2016
+                  parameters: [nu_CMS_res_j_3]
+                - id: CMS_res_j_4
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_4_2016
+                  parameters: [nu_CMS_res_j_4]
+                - id: CMS_res_j_5
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_5_2016
+                  parameters: [nu_CMS_res_j_5]
+                - id: CMS_scale_j_Total_EtaBin0
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+                  parameters: [nu_CMS_scale_j_Total_EtaBin0]
+                - id: CMS_scale_j_Total_EtaBin1
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+                  parameters: [nu_CMS_scale_j_Total_EtaBin1]
+                - id: CMS_scale_j_Total_EtaBin2
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+                  parameters: [nu_CMS_scale_j_Total_EtaBin2]
+                - id: CMS_scale_j_Total_EtaBin3
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+                  parameters: [nu_CMS_scale_j_Total_EtaBin3]
+                - id: CMS_scale_j_Total_EtaBin4
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+                  parameters: [nu_CMS_scale_j_Total_EtaBin4]
+                - id: CMS_scale_j_Total_EtaBin5
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+                  parameters: [nu_CMS_scale_j_Total_EtaBin5]
+                - id: Uncl
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_Uncl
+                  parameters: [nu_Uncl]
+
+
+jobs:
+  - id: bit_NG_PDF4LHC21_2_tt2l_delphes
+    type: bit
+    region: SR
+    process: tt2l_delphes
+    selection: null               # optional extra selection layered on top
+    numba: True
+    pdf:
+      pdf_n: [1,2,3,4,5,6]
+      pdf_type: PODBasis
+      pdf_basis: gluon_POD_nongluon_PDF4LHC21 
+    model:
+      n_trees: 200
+      learning_rate: 0.2
+      loss: MSE                   # or "CrossEntropy"
+      learn_global_score: true
+      split_mode: "binned"
+      n_bins: 256
+      quantile_bins: true  # if True: quantile edges; else uniform edges
+    runtime:
+      training_plots: true        # keep if you want training plots
+    output:
+      filename: "BIT_NG_PDF4LHC21_2_tt2l_delphes.pkl"
+
+  - id: scaler_TTLep_pow_2016
+    type: scaler
+    process: TTLep_pow_2016
+    region: SR
+    selection: null
+    output:
+      filename: "Scaler_TTLep_pow_2016.pkl"
+
+  - id: icp_TTLep_pow_2016_L1Prefire
+    type: icp
+    region: SR
+    parameters: [nu_l1prefire]
+    combinations: [[nu_l1prefire]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Dn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Up"]
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_L1Prefire.pkl
+  - id: pnn_TTLep_pow_2016_L1Prefire
+    type: pnn
+    region: SR
+    parameters: [nu_l1prefire]
+    combinations: [[nu_l1prefire]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Dn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Up"]
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_L1Prefire
+
+  - id: icp_TTLep_pow_2016_PU
+    type: icp
+    region: SR
+    parameters: [nu_pu]
+    combinations: [[nu_pu]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFUp"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_PU.pkl
+
+  - id: pnn_TTLep_pow_2016_PU
+    type: pnn
+    region: SR
+    parameters: [nu_pu]
+    combinations: [[nu_pu]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFUp"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_PU
+
+  - id: icp_TTLep_pow_2016_MuSF
+    type: icp
+    region: SR
+    parameters: [nu_MuSF]
+    combinations: [[nu_MuSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFUp"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_MuSF.pkl
+  - id: pnn_TTLep_pow_2016_MuSF
+    type: pnn
+    region: SR
+    parameters: [nu_MuSF]
+    combinations: [[nu_MuSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFUp"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_MuSF
+  - id: icp_TTLep_pow_2016_EleSF
+    type: icp
+    region: SR
+    parameters: [nu_EleSF]
+    combinations: [[nu_EleSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFUp"]
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_EleSF.pkl
+  - id: pnn_TTLep_pow_2016_EleSF
+    type: pnn
+    region: SR
+    parameters: [nu_EleSF]
+    combinations: [[nu_EleSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFUp"]
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_EleSF
+  - id: icp_TTLep_pow_2016_BTag_b
+    type: icp
+    region: SR
+    parameters: [nu_btag_b]
+    combinations: [[nu_btag_b]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFUp"]
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_BTag_b.pkl
+  - id: pnn_TTLep_pow_2016_BTag_b
+    type: pnn
+    region: SR
+    parameters: [nu_btag_b]
+    combinations: [[nu_btag_b]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFUp"]
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_BTag_b
+  - id: icp_TTLep_pow_2016_BTag_l
+    type: icp
+    region: SR
+    parameters: [nu_btag_l]
+    combinations: [[nu_btag_l]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFUp"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_BTag_l.pkl
+  - id: pnn_TTLep_pow_2016_BTag_l
+    type: pnn
+    region: SR
+    parameters: [nu_btag_l]
+    combinations: [[nu_btag_l]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFUp"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_BTag_l
+
+  - id: icp_TTLep_pow_2016_scales
+    type: icp
+    region: SR
+    parameters: [nu_mu_ren, nu_mu_fac]
+    combinations: [[nu_mu_ren], [nu_mu_fac], [nu_mu_ren, nu_mu_ren], [nu_mu_ren, 
+          nu_mu_fac], [nu_mu_fac, nu_mu_fac]]
+    base_points:
+    - coords: [-1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac0p5"]
+    - coords: [-1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac1p0"]
+    - coords: [-1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac2p0"]
+    - coords: [0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac0p5"]
+    - coords: [0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac1p0"]
+      nominal: true
+    - coords: [0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac2p0"]
+    - coords: [1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac0p5"]
+    - coords: [1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac1p0"]
+    - coords: [1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac2p0"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_scales.pkl
+
+  - id: pnn_TTLep_pow_2016_scales
+    type: pnn
+    region: SR
+    parameters: [nu_mu_ren, nu_mu_fac]
+    combinations: [[nu_mu_ren], [nu_mu_fac], [nu_mu_ren, nu_mu_ren], [nu_mu_ren, 
+          nu_mu_fac], [nu_mu_fac, nu_mu_fac]]
+    base_points:
+    - coords: [-1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac0p5"]
+    - coords: [-1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac1p0"]
+    - coords: [-1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac2p0"]
+    - coords: [0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac0p5"]
+    - coords: [0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac1p0"]
+      nominal: true
+    - coords: [0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac2p0"]
+    - coords: [1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac0p5"]
+    - coords: [1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac1p0"]
+    - coords: [1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac2p0"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_scales
+
+  - id: icp_TTLep_pow_2016_showerISR
+    type: icp
+    region: SR
+    parameters: [nu_showerISR]
+    combinations: [[nu_showerISR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_showerISR.pkl
+
+  - id: pnn_TTLep_pow_2016_showerISR
+    type: pnn
+    region: SR
+    parameters: [nu_showerISR]
+    combinations: [[nu_showerISR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_showerISR
+
+  - id: icp_TTLep_pow_2016_showerFSR
+    type: icp
+    region: SR
+    parameters: [nu_showerFSR]
+    combinations: [[nu_showerFSR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_showerFSR.pkl
+
+  - id: pnn_TTLep_pow_2016_showerFSR
+    type: pnn
+    region: SR
+    parameters: [nu_showerFSR]
+    combinations: [[nu_showerFSR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_showerFSR
+
+  - id: icp_TTLep_pow_2016_alphaS
+    type: icp
+    region: SR
+    parameters: [nu_alphaS]
+    combinations: [[nu_alphaS]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_dn"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_up"]
+ 
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_alphaS.pkl
+
+  - id: pnn_TTLep_pow_2016_alphaS
+    type: pnn
+    region: SR
+    parameters: [nu_alphaS]
+    combinations: [[nu_alphaS]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_dn"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_up"]
+ 
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_alphaS
+
+  - id: icp_TTLep_pow_2016_CMS_res_j_0_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_0]
+    combinations: [[nu_CMS_res_j_0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_0_2016.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_res_j_0_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_0]
+    combinations: [[nu_CMS_res_j_0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_0_2016
+
+  - id: icp_TTLep_pow_2016_CMS_res_j_1_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_1]
+    combinations: [[nu_CMS_res_j_1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_1_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_1_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_1]
+    combinations: [[nu_CMS_res_j_1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_1_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_2_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_2]
+    combinations: [[nu_CMS_res_j_2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_2_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_2_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_2]
+    combinations: [[nu_CMS_res_j_2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_2_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_3_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_3]
+    combinations: [[nu_CMS_res_j_3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_3_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_3_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_3]
+    combinations: [[nu_CMS_res_j_3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_3_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_4_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_4]
+    combinations: [[nu_CMS_res_j_4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_4_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_4_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_4]
+    combinations: [[nu_CMS_res_j_4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_4_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_5_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_5]
+    combinations: [[nu_CMS_res_j_5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_5_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_5_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_5]
+    combinations: [[nu_CMS_res_j_5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_5_2016
+
+  # JES Eta-split bin 0
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin0]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin0]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+
+  # JES Eta-split bin 1
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin1]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin1]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+
+  # JES Eta-split bin 2
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin2]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin2]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+
+  # JES Eta-split bin 3
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin3]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin3]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+
+  # JES Eta-split bin 4
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin4]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin4]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+
+  # JES Eta-split bin 5
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin5]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin5]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+
+  - id: icp_TTLep_pow_2016_Uncl
+    type: icp
+    region: SR
+    parameters: [nu_Uncl]
+    combinations: [[nu_Uncl]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_Uncl_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_Uncl_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_Uncl.pkl
+  - id: pnn_TTLep_pow_2016_Uncl
+    type: pnn
+    region: SR
+    parameters: [nu_Uncl]
+    combinations: [[nu_Uncl]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_Uncl_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_Uncl_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_Uncl
+
diff --git a/configs/unbinned_v5D/unbinned_delphes_3.yaml b/configs/unbinned_v5D/unbinned_delphes_3.yaml
new file mode 100644
index 0000000..40fca11
--- /dev/null
+++ b/configs/unbinned_v5D/unbinned_delphes_3.yaml
@@ -0,0 +1,1384 @@
+version: unbinned_v5D
+
+defaults:
+  module_samples: "data.samples_RunII"
+  default_features:
+    - TOP_KINEMATICS
+    - LEPTON_KINEMATICS
+    - ASYMMETRY
+
+  splitting:
+    enabled: true
+    uid_fields: ["run", "luminosityBlock", "event"]
+    seed: 42
+    n_buckets: 10000 
+
+    scheme:
+      pnn_train:     { fraction: 0.50 }
+      pnn_val:       { fraction: 0.10 }
+      c2st_train:    { fraction: 0.15 }
+      c2st_val:      { fraction: 0.05 }
+      final_eval:    { fraction: 0.20 }
+
+  early_stopping:
+    enabled: true
+    patience: 20        # same as current hard-coded
+    min_delta: 0.0      # improvement threshold; keep 0.0 to match current behavior
+    mode: "min"         # val_loss should decrease
+    warmup_epochs: 0    # optional: do not early-stop before this epoch
+
+
+likelihood:
+    regions:
+        - id: SR 
+          classifier:
+            type: null
+            id: null    # no classifier needed for a single process
+            asimov: [tt2l_delphes]
+          classes: 
+            - id: tt2l_delphes
+              sample: tt2l_delphes
+              POI:
+                job: bit_NG_PDF4LHC21_3_tt2l_delphes 
+                type: bit
+                parameters: [c0, c1, c2]
+              systematics:
+                - id: L1Prefire
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_L1Prefire
+                  parameters: [nu_l1prefire]
+                - id: PU
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_PU
+                  parameters: [nu_pu]
+                - id: MuSF 
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_MuSF
+                  parameters: [nu_MuSF]
+                - id: EleSF
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_EleSF
+                  parameters: [nu_EleSF]
+                - id: BTag_b
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_BTag_b
+                  parameters: [nu_btag_b]
+                - id: BTag_l
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_BTag_l
+                  parameters: [nu_btag_l]
+                - id: Scales
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_scales
+                  parameters: [nu_mu_ren, nu_mu_fac]
+                - id: ShowerISR
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_showerISR
+                  parameters: [nu_showerISR]
+                - id: ShowerFSR
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_showerFSR
+                  parameters: [nu_showerFSR]
+                - id: AlphaS
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_alphaS
+                  parameters: [nu_alphaS]
+                - id: CMS_res_j_0
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_0_2016
+                  parameters: [nu_CMS_res_j_0]
+                - id: CMS_res_j_1
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_1_2016
+                  parameters: [nu_CMS_res_j_1]
+                - id: CMS_res_j_2
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_2_2016
+                  parameters: [nu_CMS_res_j_2]
+                - id: CMS_res_j_3
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_3_2016
+                  parameters: [nu_CMS_res_j_3]
+                - id: CMS_res_j_4
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_4_2016
+                  parameters: [nu_CMS_res_j_4]
+                - id: CMS_res_j_5
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_5_2016
+                  parameters: [nu_CMS_res_j_5]
+                - id: CMS_scale_j_Total_EtaBin0
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+                  parameters: [nu_CMS_scale_j_Total_EtaBin0]
+                - id: CMS_scale_j_Total_EtaBin1
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+                  parameters: [nu_CMS_scale_j_Total_EtaBin1]
+                - id: CMS_scale_j_Total_EtaBin2
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+                  parameters: [nu_CMS_scale_j_Total_EtaBin2]
+                - id: CMS_scale_j_Total_EtaBin3
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+                  parameters: [nu_CMS_scale_j_Total_EtaBin3]
+                - id: CMS_scale_j_Total_EtaBin4
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+                  parameters: [nu_CMS_scale_j_Total_EtaBin4]
+                - id: CMS_scale_j_Total_EtaBin5
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+                  parameters: [nu_CMS_scale_j_Total_EtaBin5]
+                - id: Uncl
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_Uncl
+                  parameters: [nu_Uncl]
+
+
+jobs:
+  - id: bit_NG_PDF4LHC21_3_tt2l_delphes
+    type: bit
+    region: SR
+    process: tt2l_delphes
+    selection: null               # optional extra selection layered on top
+    numba: True
+    pdf:
+      pdf_n: [1,2,3]
+      pdf_type: PODBasis
+      pdf_basis: gluon_POD_nongluon_PDF4LHC21 
+    model:
+      n_trees: 200
+      learning_rate: 0.2
+      loss: MSE                   # or "CrossEntropy"
+      learn_global_score: true
+      split_mode: "binned"
+      n_bins: 256
+      quantile_bins: true  # if True: quantile edges; else uniform edges
+    runtime:
+      training_plots: true        # keep if you want training plots
+    output:
+      filename: "BIT_NG_PDF4LHC21_3_tt2l_delphes.pkl"
+
+  - id: scaler_TTLep_pow_2016
+    type: scaler
+    process: TTLep_pow_2016
+    region: SR
+    selection: null
+    output:
+      filename: "Scaler_TTLep_pow_2016.pkl"
+
+  - id: icp_TTLep_pow_2016_L1Prefire
+    type: icp
+    region: SR
+    parameters: [nu_l1prefire]
+    combinations: [[nu_l1prefire]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Dn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Up"]
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_L1Prefire.pkl
+  - id: pnn_TTLep_pow_2016_L1Prefire
+    type: pnn
+    region: SR
+    parameters: [nu_l1prefire]
+    combinations: [[nu_l1prefire]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Dn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Up"]
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_L1Prefire
+
+  - id: icp_TTLep_pow_2016_PU
+    type: icp
+    region: SR
+    parameters: [nu_pu]
+    combinations: [[nu_pu]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFUp"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_PU.pkl
+
+  - id: pnn_TTLep_pow_2016_PU
+    type: pnn
+    region: SR
+    parameters: [nu_pu]
+    combinations: [[nu_pu]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFUp"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_PU
+
+  - id: icp_TTLep_pow_2016_MuSF
+    type: icp
+    region: SR
+    parameters: [nu_MuSF]
+    combinations: [[nu_MuSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFUp"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_MuSF.pkl
+  - id: pnn_TTLep_pow_2016_MuSF
+    type: pnn
+    region: SR
+    parameters: [nu_MuSF]
+    combinations: [[nu_MuSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFUp"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_MuSF
+  - id: icp_TTLep_pow_2016_EleSF
+    type: icp
+    region: SR
+    parameters: [nu_EleSF]
+    combinations: [[nu_EleSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFUp"]
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_EleSF.pkl
+  - id: pnn_TTLep_pow_2016_EleSF
+    type: pnn
+    region: SR
+    parameters: [nu_EleSF]
+    combinations: [[nu_EleSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFUp"]
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_EleSF
+  - id: icp_TTLep_pow_2016_BTag_b
+    type: icp
+    region: SR
+    parameters: [nu_btag_b]
+    combinations: [[nu_btag_b]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFUp"]
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_BTag_b.pkl
+  - id: pnn_TTLep_pow_2016_BTag_b
+    type: pnn
+    region: SR
+    parameters: [nu_btag_b]
+    combinations: [[nu_btag_b]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFUp"]
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_BTag_b
+  - id: icp_TTLep_pow_2016_BTag_l
+    type: icp
+    region: SR
+    parameters: [nu_btag_l]
+    combinations: [[nu_btag_l]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFUp"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_BTag_l.pkl
+  - id: pnn_TTLep_pow_2016_BTag_l
+    type: pnn
+    region: SR
+    parameters: [nu_btag_l]
+    combinations: [[nu_btag_l]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFUp"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_BTag_l
+
+  - id: icp_TTLep_pow_2016_scales
+    type: icp
+    region: SR
+    parameters: [nu_mu_ren, nu_mu_fac]
+    combinations: [[nu_mu_ren], [nu_mu_fac], [nu_mu_ren, nu_mu_ren], [nu_mu_ren, 
+          nu_mu_fac], [nu_mu_fac, nu_mu_fac]]
+    base_points:
+    - coords: [-1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac0p5"]
+    - coords: [-1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac1p0"]
+    - coords: [-1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac2p0"]
+    - coords: [0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac0p5"]
+    - coords: [0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac1p0"]
+      nominal: true
+    - coords: [0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac2p0"]
+    - coords: [1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac0p5"]
+    - coords: [1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac1p0"]
+    - coords: [1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac2p0"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_scales.pkl
+
+  - id: pnn_TTLep_pow_2016_scales
+    type: pnn
+    region: SR
+    parameters: [nu_mu_ren, nu_mu_fac]
+    combinations: [[nu_mu_ren], [nu_mu_fac], [nu_mu_ren, nu_mu_ren], [nu_mu_ren, 
+          nu_mu_fac], [nu_mu_fac, nu_mu_fac]]
+    base_points:
+    - coords: [-1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac0p5"]
+    - coords: [-1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac1p0"]
+    - coords: [-1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac2p0"]
+    - coords: [0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac0p5"]
+    - coords: [0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac1p0"]
+      nominal: true
+    - coords: [0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac2p0"]
+    - coords: [1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac0p5"]
+    - coords: [1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac1p0"]
+    - coords: [1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac2p0"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_scales
+
+  - id: icp_TTLep_pow_2016_showerISR
+    type: icp
+    region: SR
+    parameters: [nu_showerISR]
+    combinations: [[nu_showerISR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_showerISR.pkl
+
+  - id: pnn_TTLep_pow_2016_showerISR
+    type: pnn
+    region: SR
+    parameters: [nu_showerISR]
+    combinations: [[nu_showerISR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_showerISR
+
+  - id: icp_TTLep_pow_2016_showerFSR
+    type: icp
+    region: SR
+    parameters: [nu_showerFSR]
+    combinations: [[nu_showerFSR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_showerFSR.pkl
+
+  - id: pnn_TTLep_pow_2016_showerFSR
+    type: pnn
+    region: SR
+    parameters: [nu_showerFSR]
+    combinations: [[nu_showerFSR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_showerFSR
+
+  - id: icp_TTLep_pow_2016_alphaS
+    type: icp
+    region: SR
+    parameters: [nu_alphaS]
+    combinations: [[nu_alphaS]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_dn"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_up"]
+ 
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_alphaS.pkl
+
+  - id: pnn_TTLep_pow_2016_alphaS
+    type: pnn
+    region: SR
+    parameters: [nu_alphaS]
+    combinations: [[nu_alphaS]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_dn"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_up"]
+ 
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_alphaS
+
+  - id: icp_TTLep_pow_2016_CMS_res_j_0_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_0]
+    combinations: [[nu_CMS_res_j_0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_0_2016.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_res_j_0_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_0]
+    combinations: [[nu_CMS_res_j_0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_0_2016
+
+  - id: icp_TTLep_pow_2016_CMS_res_j_1_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_1]
+    combinations: [[nu_CMS_res_j_1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_1_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_1_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_1]
+    combinations: [[nu_CMS_res_j_1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_1_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_2_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_2]
+    combinations: [[nu_CMS_res_j_2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_2_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_2_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_2]
+    combinations: [[nu_CMS_res_j_2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_2_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_3_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_3]
+    combinations: [[nu_CMS_res_j_3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_3_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_3_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_3]
+    combinations: [[nu_CMS_res_j_3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_3_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_4_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_4]
+    combinations: [[nu_CMS_res_j_4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_4_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_4_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_4]
+    combinations: [[nu_CMS_res_j_4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_4_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_5_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_5]
+    combinations: [[nu_CMS_res_j_5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_5_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_5_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_5]
+    combinations: [[nu_CMS_res_j_5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_5_2016
+
+  # JES Eta-split bin 0
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin0]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin0]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+
+  # JES Eta-split bin 1
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin1]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin1]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+
+  # JES Eta-split bin 2
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin2]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin2]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+
+  # JES Eta-split bin 3
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin3]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin3]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+
+  # JES Eta-split bin 4
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin4]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin4]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+
+  # JES Eta-split bin 5
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin5]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin5]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+
+  - id: icp_TTLep_pow_2016_Uncl
+    type: icp
+    region: SR
+    parameters: [nu_Uncl]
+    combinations: [[nu_Uncl]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_Uncl_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_Uncl_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_Uncl.pkl
+  - id: pnn_TTLep_pow_2016_Uncl
+    type: pnn
+    region: SR
+    parameters: [nu_Uncl]
+    combinations: [[nu_Uncl]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_Uncl_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_Uncl_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_Uncl
+
diff --git a/configs/unbinned_v5D/unbinned_delphes_6_RunII.yaml b/configs/unbinned_v5D/unbinned_delphes_6_RunII.yaml
new file mode 100644
index 0000000..214aac9
--- /dev/null
+++ b/configs/unbinned_v5D/unbinned_delphes_6_RunII.yaml
@@ -0,0 +1,1388 @@
+version: unbinned_v5D
+
+defaults:
+  module_samples: "data.samples_RunII"
+  default_features:
+    - TOP_KINEMATICS
+    - LEPTON_KINEMATICS
+    - ASYMMETRY
+
+  splitting:
+    enabled: true
+    uid_fields: ["run", "luminosityBlock", "event"]
+    seed: 42
+    n_buckets: 10000 
+
+    scheme:
+      pnn_train:     { fraction: 0.50 }
+      pnn_val:       { fraction: 0.10 }
+      c2st_train:    { fraction: 0.15 }
+      c2st_val:      { fraction: 0.05 }
+      final_eval:    { fraction: 0.20 }
+
+  early_stopping:
+    enabled: true
+    patience: 20        # same as current hard-coded
+    min_delta: 0.0      # improvement threshold; keep 0.0 to match current behavior
+    mode: "min"         # val_loss should decrease
+    warmup_epochs: 0    # optional: do not early-stop before this epoch
+
+
+likelihood:
+    regions:
+        - id: SR 
+          classifier:
+            type: null
+            id: null    # no classifier needed for a single process
+            asimov: [tt2l_delphes_RunII]
+          classes: 
+            - id: tt2l_delphes
+              sample: tt2l_delphes_RunII 
+              POI:
+                job: bit_NG_PDF4LHC21_6_tt2l_delphes 
+                type: bit
+                parameters: [c0, c1, c2, c3, c4, c5]
+              systematics:
+                - id: lumi 
+                  type: lnN
+                  value: 0.0073
+                  parameters: [nu_lumi]
+                - id: L1Prefire
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_L1Prefire
+                  parameters: [nu_l1prefire]
+                - id: PU
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_PU
+                  parameters: [nu_pu]
+                - id: MuSF 
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_MuSF
+                  parameters: [nu_MuSF]
+                - id: EleSF
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_EleSF
+                  parameters: [nu_EleSF]
+                - id: BTag_b
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_BTag_b
+                  parameters: [nu_btag_b]
+                - id: BTag_l
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_BTag_l
+                  parameters: [nu_btag_l]
+                - id: Scales
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_scales
+                  parameters: [nu_mu_ren, nu_mu_fac]
+                - id: ShowerISR
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_showerISR
+                  parameters: [nu_showerISR]
+                - id: ShowerFSR
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_showerFSR
+                  parameters: [nu_showerFSR]
+                - id: AlphaS
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_alphaS
+                  parameters: [nu_alphaS]
+                - id: CMS_res_j_0
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_0_2016
+                  parameters: [nu_CMS_res_j_0]
+                - id: CMS_res_j_1
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_1_2016
+                  parameters: [nu_CMS_res_j_1]
+                - id: CMS_res_j_2
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_2_2016
+                  parameters: [nu_CMS_res_j_2]
+                - id: CMS_res_j_3
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_3_2016
+                  parameters: [nu_CMS_res_j_3]
+                - id: CMS_res_j_4
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_4_2016
+                  parameters: [nu_CMS_res_j_4]
+                - id: CMS_res_j_5
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_5_2016
+                  parameters: [nu_CMS_res_j_5]
+                - id: CMS_scale_j_Total_EtaBin0
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+                  parameters: [nu_CMS_scale_j_Total_EtaBin0]
+                - id: CMS_scale_j_Total_EtaBin1
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+                  parameters: [nu_CMS_scale_j_Total_EtaBin1]
+                - id: CMS_scale_j_Total_EtaBin2
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+                  parameters: [nu_CMS_scale_j_Total_EtaBin2]
+                - id: CMS_scale_j_Total_EtaBin3
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+                  parameters: [nu_CMS_scale_j_Total_EtaBin3]
+                - id: CMS_scale_j_Total_EtaBin4
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+                  parameters: [nu_CMS_scale_j_Total_EtaBin4]
+                - id: CMS_scale_j_Total_EtaBin5
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+                  parameters: [nu_CMS_scale_j_Total_EtaBin5]
+                - id: Uncl
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_Uncl
+                  parameters: [nu_Uncl]
+
+
+jobs:
+  - id: bit_NG_PDF4LHC21_6_tt2l_delphes
+    type: bit
+    region: SR
+    process: tt2l_delphes_RunII
+    selection: null               # optional extra selection layered on top
+    numba: True
+    pdf:
+      pdf_n: [1,2,3,4,5,6]
+      pdf_type: PODBasis
+      pdf_basis: gluon_POD_nongluon_PDF4LHC21 
+    model:
+      n_trees: 200
+      learning_rate: 0.2
+      loss: MSE                   # or "CrossEntropy"
+      learn_global_score: true
+      split_mode: "binned"
+      n_bins: 256
+      quantile_bins: true  # if True: quantile edges; else uniform edges
+    runtime:
+      training_plots: true        # keep if you want training plots
+    output:
+      filename: "BIT_NG_PDF4LHC21_6_tt2l_delphes.pkl"
+
+  - id: scaler_TTLep_pow_2016
+    type: scaler
+    process: TTLep_pow_2016
+    region: SR
+    selection: null
+    output:
+      filename: "Scaler_TTLep_pow_2016.pkl"
+
+  - id: icp_TTLep_pow_2016_L1Prefire
+    type: icp
+    region: SR
+    parameters: [nu_l1prefire]
+    combinations: [[nu_l1prefire]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Dn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Up"]
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_L1Prefire.pkl
+  - id: pnn_TTLep_pow_2016_L1Prefire
+    type: pnn
+    region: SR
+    parameters: [nu_l1prefire]
+    combinations: [[nu_l1prefire]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Dn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Up"]
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_L1Prefire
+
+  - id: icp_TTLep_pow_2016_PU
+    type: icp
+    region: SR
+    parameters: [nu_pu]
+    combinations: [[nu_pu]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFUp"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_PU.pkl
+
+  - id: pnn_TTLep_pow_2016_PU
+    type: pnn
+    region: SR
+    parameters: [nu_pu]
+    combinations: [[nu_pu]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFUp"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_PU
+
+  - id: icp_TTLep_pow_2016_MuSF
+    type: icp
+    region: SR
+    parameters: [nu_MuSF]
+    combinations: [[nu_MuSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFUp"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_MuSF.pkl
+  - id: pnn_TTLep_pow_2016_MuSF
+    type: pnn
+    region: SR
+    parameters: [nu_MuSF]
+    combinations: [[nu_MuSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFUp"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_MuSF
+  - id: icp_TTLep_pow_2016_EleSF
+    type: icp
+    region: SR
+    parameters: [nu_EleSF]
+    combinations: [[nu_EleSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFUp"]
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_EleSF.pkl
+  - id: pnn_TTLep_pow_2016_EleSF
+    type: pnn
+    region: SR
+    parameters: [nu_EleSF]
+    combinations: [[nu_EleSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFUp"]
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_EleSF
+  - id: icp_TTLep_pow_2016_BTag_b
+    type: icp
+    region: SR
+    parameters: [nu_btag_b]
+    combinations: [[nu_btag_b]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFUp"]
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_BTag_b.pkl
+  - id: pnn_TTLep_pow_2016_BTag_b
+    type: pnn
+    region: SR
+    parameters: [nu_btag_b]
+    combinations: [[nu_btag_b]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFUp"]
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_BTag_b
+  - id: icp_TTLep_pow_2016_BTag_l
+    type: icp
+    region: SR
+    parameters: [nu_btag_l]
+    combinations: [[nu_btag_l]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFUp"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_BTag_l.pkl
+  - id: pnn_TTLep_pow_2016_BTag_l
+    type: pnn
+    region: SR
+    parameters: [nu_btag_l]
+    combinations: [[nu_btag_l]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFUp"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_BTag_l
+
+  - id: icp_TTLep_pow_2016_scales
+    type: icp
+    region: SR
+    parameters: [nu_mu_ren, nu_mu_fac]
+    combinations: [[nu_mu_ren], [nu_mu_fac], [nu_mu_ren, nu_mu_ren], [nu_mu_ren, 
+          nu_mu_fac], [nu_mu_fac, nu_mu_fac]]
+    base_points:
+    - coords: [-1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac0p5"]
+    - coords: [-1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac1p0"]
+    - coords: [-1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac2p0"]
+    - coords: [0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac0p5"]
+    - coords: [0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac1p0"]
+      nominal: true
+    - coords: [0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac2p0"]
+    - coords: [1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac0p5"]
+    - coords: [1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac1p0"]
+    - coords: [1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac2p0"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_scales.pkl
+
+  - id: pnn_TTLep_pow_2016_scales
+    type: pnn
+    region: SR
+    parameters: [nu_mu_ren, nu_mu_fac]
+    combinations: [[nu_mu_ren], [nu_mu_fac], [nu_mu_ren, nu_mu_ren], [nu_mu_ren, 
+          nu_mu_fac], [nu_mu_fac, nu_mu_fac]]
+    base_points:
+    - coords: [-1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac0p5"]
+    - coords: [-1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac1p0"]
+    - coords: [-1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac2p0"]
+    - coords: [0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac0p5"]
+    - coords: [0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac1p0"]
+      nominal: true
+    - coords: [0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac2p0"]
+    - coords: [1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac0p5"]
+    - coords: [1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac1p0"]
+    - coords: [1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac2p0"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_scales
+
+  - id: icp_TTLep_pow_2016_showerISR
+    type: icp
+    region: SR
+    parameters: [nu_showerISR]
+    combinations: [[nu_showerISR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_showerISR.pkl
+
+  - id: pnn_TTLep_pow_2016_showerISR
+    type: pnn
+    region: SR
+    parameters: [nu_showerISR]
+    combinations: [[nu_showerISR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_showerISR
+
+  - id: icp_TTLep_pow_2016_showerFSR
+    type: icp
+    region: SR
+    parameters: [nu_showerFSR]
+    combinations: [[nu_showerFSR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_showerFSR.pkl
+
+  - id: pnn_TTLep_pow_2016_showerFSR
+    type: pnn
+    region: SR
+    parameters: [nu_showerFSR]
+    combinations: [[nu_showerFSR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_showerFSR
+
+  - id: icp_TTLep_pow_2016_alphaS
+    type: icp
+    region: SR
+    parameters: [nu_alphaS]
+    combinations: [[nu_alphaS]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_dn"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_up"]
+ 
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_alphaS.pkl
+
+  - id: pnn_TTLep_pow_2016_alphaS
+    type: pnn
+    region: SR
+    parameters: [nu_alphaS]
+    combinations: [[nu_alphaS]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_dn"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_up"]
+ 
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_alphaS
+
+  - id: icp_TTLep_pow_2016_CMS_res_j_0_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_0]
+    combinations: [[nu_CMS_res_j_0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_0_2016.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_res_j_0_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_0]
+    combinations: [[nu_CMS_res_j_0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_0_2016
+
+  - id: icp_TTLep_pow_2016_CMS_res_j_1_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_1]
+    combinations: [[nu_CMS_res_j_1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_1_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_1_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_1]
+    combinations: [[nu_CMS_res_j_1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_1_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_2_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_2]
+    combinations: [[nu_CMS_res_j_2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_2_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_2_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_2]
+    combinations: [[nu_CMS_res_j_2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_2_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_3_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_3]
+    combinations: [[nu_CMS_res_j_3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_3_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_3_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_3]
+    combinations: [[nu_CMS_res_j_3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_3_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_4_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_4]
+    combinations: [[nu_CMS_res_j_4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_4_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_4_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_4]
+    combinations: [[nu_CMS_res_j_4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_4_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_5_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_5]
+    combinations: [[nu_CMS_res_j_5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_5_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_5_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_5]
+    combinations: [[nu_CMS_res_j_5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_5_2016
+
+  # JES Eta-split bin 0
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin0]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin0]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+
+  # JES Eta-split bin 1
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin1]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin1]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+
+  # JES Eta-split bin 2
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin2]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin2]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+
+  # JES Eta-split bin 3
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin3]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin3]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+
+  # JES Eta-split bin 4
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin4]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin4]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+
+  # JES Eta-split bin 5
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin5]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin5]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+
+  - id: icp_TTLep_pow_2016_Uncl
+    type: icp
+    region: SR
+    parameters: [nu_Uncl]
+    combinations: [[nu_Uncl]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_Uncl_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_Uncl_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_Uncl.pkl
+  - id: pnn_TTLep_pow_2016_Uncl
+    type: pnn
+    region: SR
+    parameters: [nu_Uncl]
+    combinations: [[nu_Uncl]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_Uncl_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_Uncl_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_Uncl
+
diff --git a/configs/unbinned_v5D/unbinned_delphes_7_RunII.yaml b/configs/unbinned_v5D/unbinned_delphes_7_RunII.yaml
new file mode 100644
index 0000000..41b7471
--- /dev/null
+++ b/configs/unbinned_v5D/unbinned_delphes_7_RunII.yaml
@@ -0,0 +1,1388 @@
+version: unbinned_v5D
+
+defaults:
+  module_samples: "data.samples_RunII"
+  default_features:
+    - TOP_KINEMATICS
+    - LEPTON_KINEMATICS
+    - ASYMMETRY
+
+  splitting:
+    enabled: true
+    uid_fields: ["run", "luminosityBlock", "event"]
+    seed: 42
+    n_buckets: 10000 
+
+    scheme:
+      pnn_train:     { fraction: 0.50 }
+      pnn_val:       { fraction: 0.10 }
+      c2st_train:    { fraction: 0.15 }
+      c2st_val:      { fraction: 0.05 }
+      final_eval:    { fraction: 0.20 }
+
+  early_stopping:
+    enabled: true
+    patience: 20        # same as current hard-coded
+    min_delta: 0.0      # improvement threshold; keep 0.0 to match current behavior
+    mode: "min"         # val_loss should decrease
+    warmup_epochs: 0    # optional: do not early-stop before this epoch
+
+
+likelihood:
+    regions:
+        - id: SR 
+          classifier:
+            type: null
+            id: null    # no classifier needed for a single process
+            asimov: [tt2l_delphes_RunII]
+          classes: 
+            - id: tt2l_delphes
+              sample: tt2l_delphes_RunII 
+              POI:
+                job: bit_NG_PDF4LHC21_7_tt2l_delphes 
+                type: bit
+                parameters: [c0, c1, c2, c3, c4, c5,c7]
+              systematics:
+                - id: lumi 
+                  type: lnN
+                  value: 0.0073
+                  parameters: [nu_lumi]
+                - id: L1Prefire
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_L1Prefire
+                  parameters: [nu_l1prefire]
+                - id: PU
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_PU
+                  parameters: [nu_pu]
+                - id: MuSF 
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_MuSF
+                  parameters: [nu_MuSF]
+                - id: EleSF
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_EleSF
+                  parameters: [nu_EleSF]
+                - id: BTag_b
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_BTag_b
+                  parameters: [nu_btag_b]
+                - id: BTag_l
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_BTag_l
+                  parameters: [nu_btag_l]
+                - id: Scales
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_scales
+                  parameters: [nu_mu_ren, nu_mu_fac]
+                - id: ShowerISR
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_showerISR
+                  parameters: [nu_showerISR]
+                - id: ShowerFSR
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_showerFSR
+                  parameters: [nu_showerFSR]
+                - id: AlphaS
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_alphaS
+                  parameters: [nu_alphaS]
+                - id: CMS_res_j_0
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_0_2016
+                  parameters: [nu_CMS_res_j_0]
+                - id: CMS_res_j_1
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_1_2016
+                  parameters: [nu_CMS_res_j_1]
+                - id: CMS_res_j_2
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_2_2016
+                  parameters: [nu_CMS_res_j_2]
+                - id: CMS_res_j_3
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_3_2016
+                  parameters: [nu_CMS_res_j_3]
+                - id: CMS_res_j_4
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_4_2016
+                  parameters: [nu_CMS_res_j_4]
+                - id: CMS_res_j_5
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_res_j_5_2016
+                  parameters: [nu_CMS_res_j_5]
+                - id: CMS_scale_j_Total_EtaBin0
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+                  parameters: [nu_CMS_scale_j_Total_EtaBin0]
+                - id: CMS_scale_j_Total_EtaBin1
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+                  parameters: [nu_CMS_scale_j_Total_EtaBin1]
+                - id: CMS_scale_j_Total_EtaBin2
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+                  parameters: [nu_CMS_scale_j_Total_EtaBin2]
+                - id: CMS_scale_j_Total_EtaBin3
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+                  parameters: [nu_CMS_scale_j_Total_EtaBin3]
+                - id: CMS_scale_j_Total_EtaBin4
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+                  parameters: [nu_CMS_scale_j_Total_EtaBin4]
+                - id: CMS_scale_j_Total_EtaBin5
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+                  parameters: [nu_CMS_scale_j_Total_EtaBin5]
+                - id: Uncl
+                  type: pnn
+                  job: pnn_TTLep_pow_2016_Uncl
+                  parameters: [nu_Uncl]
+
+
+jobs:
+  - id: bit_NG_PDF4LHC21_7_tt2l_delphes
+    type: bit
+    region: SR
+    process: tt2l_delphes
+    selection: null               # optional extra selection layered on top
+    numba: True
+    pdf:
+      pdf_n: [1,2,3,4,5,6,7]
+      pdf_type: PODBasis
+      pdf_basis: gluon_POD_nongluon_PDF4LHC21 
+    model:
+      n_trees: 200
+      learning_rate: 0.2
+      loss: MSE                   # or "CrossEntropy"
+      learn_global_score: true
+      split_mode: "binned"
+      n_bins: 256
+      quantile_bins: true  # if True: quantile edges; else uniform edges
+    runtime:
+      training_plots: true        # keep if you want training plots
+    output:
+      filename: "BIT_NG_PDF4LHC21_7_tt2l_delphes.pkl"
+
+  - id: scaler_TTLep_pow_2016
+    type: scaler
+    process: TTLep_pow_2016
+    region: SR
+    selection: null
+    output:
+      filename: "Scaler_TTLep_pow_2016.pkl"
+
+  - id: icp_TTLep_pow_2016_L1Prefire
+    type: icp
+    region: SR
+    parameters: [nu_l1prefire]
+    combinations: [[nu_l1prefire]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Dn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Up"]
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_L1Prefire.pkl
+  - id: pnn_TTLep_pow_2016_L1Prefire
+    type: pnn
+    region: SR
+    parameters: [nu_l1prefire]
+    combinations: [[nu_l1prefire]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Dn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["L1PreFiringWeight_Nom"]
+      addweights: ["L1PreFiringWeight_Up"]
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_L1Prefire
+
+  - id: icp_TTLep_pow_2016_PU
+    type: icp
+    region: SR
+    parameters: [nu_pu]
+    combinations: [[nu_pu]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFUp"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_PU.pkl
+
+  - id: pnn_TTLep_pow_2016_PU
+    type: pnn
+    region: SR
+    parameters: [nu_pu]
+    combinations: [[nu_pu]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["Pileup_SF"]
+      addweights: ["Pileup_SFUp"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_PU
+
+  - id: icp_TTLep_pow_2016_MuSF
+    type: icp
+    region: SR
+    parameters: [nu_MuSF]
+    combinations: [[nu_MuSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFUp"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_MuSF.pkl
+  - id: pnn_TTLep_pow_2016_MuSF
+    type: pnn
+    region: SR
+    parameters: [nu_MuSF]
+    combinations: [[nu_MuSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepMu_SF"]
+      addweights: ["lepMu_SFUp"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_MuSF
+  - id: icp_TTLep_pow_2016_EleSF
+    type: icp
+    region: SR
+    parameters: [nu_EleSF]
+    combinations: [[nu_EleSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFUp"]
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_EleSF.pkl
+  - id: pnn_TTLep_pow_2016_EleSF
+    type: pnn
+    region: SR
+    parameters: [nu_EleSF]
+    combinations: [[nu_EleSF]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["lepEle_SF"]
+      addweights: ["lepEle_SFUp"]
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_EleSF
+  - id: icp_TTLep_pow_2016_BTag_b
+    type: icp
+    region: SR
+    parameters: [nu_btag_b]
+    combinations: [[nu_btag_b]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFUp"]
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_BTag_b.pkl
+  - id: pnn_TTLep_pow_2016_BTag_b
+    type: pnn
+    region: SR
+    parameters: [nu_btag_b]
+    combinations: [[nu_btag_b]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFUp"]
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_BTag_b
+  - id: icp_TTLep_pow_2016_BTag_l
+    type: icp
+    region: SR
+    parameters: [nu_btag_l]
+    combinations: [[nu_btag_l]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFUp"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_BTag_l.pkl
+  - id: pnn_TTLep_pow_2016_BTag_l
+    type: pnn
+    region: SR
+    parameters: [nu_btag_l]
+    combinations: [[nu_btag_l]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFDn"]
+    - coords: [0.0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016
+      removeweights: ["btagSF_fixedWP_SF"]
+      addweights: ["btagSF_fixedWP_SF__CMS_eff_b_light_SFUp"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_BTag_l
+
+  - id: icp_TTLep_pow_2016_scales
+    type: icp
+    region: SR
+    parameters: [nu_mu_ren, nu_mu_fac]
+    combinations: [[nu_mu_ren], [nu_mu_fac], [nu_mu_ren, nu_mu_ren], [nu_mu_ren, 
+          nu_mu_fac], [nu_mu_fac, nu_mu_fac]]
+    base_points:
+    - coords: [-1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac0p5"]
+    - coords: [-1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac1p0"]
+    - coords: [-1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac2p0"]
+    - coords: [0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac0p5"]
+    - coords: [0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac1p0"]
+      nominal: true
+    - coords: [0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac2p0"]
+    - coords: [1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac0p5"]
+    - coords: [1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac1p0"]
+    - coords: [1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac2p0"]
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_scales.pkl
+
+  - id: pnn_TTLep_pow_2016_scales
+    type: pnn
+    region: SR
+    parameters: [nu_mu_ren, nu_mu_fac]
+    combinations: [[nu_mu_ren], [nu_mu_fac], [nu_mu_ren, nu_mu_ren], [nu_mu_ren, 
+          nu_mu_fac], [nu_mu_fac, nu_mu_fac]]
+    base_points:
+    - coords: [-1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac0p5"]
+    - coords: [-1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac1p0"]
+    - coords: [-1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren0p5_fac2p0"]
+    - coords: [0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac0p5"]
+    - coords: [0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac1p0"]
+      nominal: true
+    - coords: [0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren1p0_fac2p0"]
+    - coords: [1.0, -1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac0p5"]
+    - coords: [1.0, 0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac1p0"]
+    - coords: [1.0, 1.0]
+      loader: TTLep_pow_2016
+      addweights: ["scale_ren2p0_fac2p0"]
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_scales
+
+  - id: icp_TTLep_pow_2016_showerISR
+    type: icp
+    region: SR
+    parameters: [nu_showerISR]
+    combinations: [[nu_showerISR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_showerISR.pkl
+
+  - id: pnn_TTLep_pow_2016_showerISR
+    type: pnn
+    region: SR
+    parameters: [nu_showerISR]
+    combinations: [[nu_showerISR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_showerISR
+
+  - id: icp_TTLep_pow_2016_showerFSR
+    type: icp
+    region: SR
+    parameters: [nu_showerFSR]
+    combinations: [[nu_showerFSR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_showerFSR.pkl
+
+  - id: pnn_TTLep_pow_2016_showerFSR
+    type: pnn
+    region: SR
+    parameters: [nu_showerFSR]
+    combinations: [[nu_showerFSR]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr0p5_fsr1p0"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["shower_isr2p0_fsr1p0"]
+ 
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_showerFSR
+
+  - id: icp_TTLep_pow_2016_alphaS
+    type: icp
+    region: SR
+    parameters: [nu_alphaS]
+    combinations: [[nu_alphaS]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_dn"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_up"]
+ 
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_alphaS.pkl
+
+  - id: pnn_TTLep_pow_2016_alphaS
+    type: pnn
+    region: SR
+    parameters: [nu_alphaS]
+    combinations: [[nu_alphaS]]
+    base_points:
+      - coords: [-1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_dn"]
+      - coords: [0]
+        loader: TTLep_pow_2016
+        nominal: true
+      - coords: [1.0]
+        loader: TTLep_pow_2016
+        addweights: ["pdf_alphas_up"]
+ 
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_alphaS
+
+  - id: icp_TTLep_pow_2016_CMS_res_j_0_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_0]
+    combinations: [[nu_CMS_res_j_0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_0_2016.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_res_j_0_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_0]
+    combinations: [[nu_CMS_res_j_0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_0_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_0_2016
+
+  - id: icp_TTLep_pow_2016_CMS_res_j_1_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_1]
+    combinations: [[nu_CMS_res_j_1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_1_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_1_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_1]
+    combinations: [[nu_CMS_res_j_1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_1_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_1_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_2_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_2]
+    combinations: [[nu_CMS_res_j_2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_2_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_2_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_2]
+    combinations: [[nu_CMS_res_j_2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_2_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_2_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_3_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_3]
+    combinations: [[nu_CMS_res_j_3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_3_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_3_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_3]
+    combinations: [[nu_CMS_res_j_3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_3_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_3_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_4_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_4]
+    combinations: [[nu_CMS_res_j_4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_4_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_4_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_4]
+    combinations: [[nu_CMS_res_j_4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_4_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_4_2016
+  - id: icp_TTLep_pow_2016_CMS_res_j_5_2016
+    type: icp
+    region: SR
+    parameters: [nu_CMS_res_j_5]
+    combinations: [[nu_CMS_res_j_5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_res_j_5_2016.pkl
+  - id: pnn_TTLep_pow_2016_CMS_res_j_5_2016
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_res_j_5]
+    combinations: [[nu_CMS_res_j_5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_res_j_5_2016_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_res_j_5_2016
+
+  # JES Eta-split bin 0
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin0]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin0]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin0]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin0_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin0
+
+  # JES Eta-split bin 1
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin1]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin1]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin1]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin1_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin1
+
+  # JES Eta-split bin 2
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin2]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin2]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin2]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin2_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin2
+
+  # JES Eta-split bin 3
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin3]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin3]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin3]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin3_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin3
+
+  # JES Eta-split bin 4
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin4]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin4]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin4]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin4_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin4
+
+  # JES Eta-split bin 5
+  - id: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+    type: icp
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin5]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5.pkl
+
+  - id: pnn_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+    type: pnn
+    region: SR
+    parameters: [nu_CMS_scale_j_Total_EtaBin5]
+    combinations: [[nu_CMS_scale_j_Total_EtaBin5]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_CMS_scale_j_Total_EtaBin5_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_CMS_scale_j_Total_EtaBin5
+
+  - id: icp_TTLep_pow_2016_Uncl
+    type: icp
+    region: SR
+    parameters: [nu_Uncl]
+    combinations: [[nu_Uncl]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_Uncl_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_Uncl_up
+  
+    train_ratio: true
+    output:
+      filename: icp_TTLep_pow_2016_Uncl.pkl
+  - id: pnn_TTLep_pow_2016_Uncl
+    type: pnn
+    region: SR
+    parameters: [nu_Uncl]
+    combinations: [[nu_Uncl]]
+    base_points:
+    - coords: [-1.0]
+      loader: TTLep_pow_2016_Uncl_down
+    - coords: [0]
+      loader: TTLep_pow_2016
+      nominal: true
+    - coords: [1.0]
+      loader: TTLep_pow_2016_Uncl_up
+  
+    model:
+      hidden_layers:
+      - 128
+      - 128
+      activation: relu
+      initialize_zero: true
+    optim:
+      epochs: 200
+      phaseout_epochs: 50
+      learning_rate: 0.001
+    runtime:
+      n_split: 10
+      rebin: 2
+    extras:
+      use_scaler: scaler_TTLep_pow_2016
+      use_icp: icp_TTLep_pow_2016_Uncl
+
diff --git a/configs/unbinned_v6/unbinned_2016.yaml b/configs/unbinned_v6/unbinned_2016.yaml
index 5742630..89def18 100644
--- a/configs/unbinned_v6/unbinned_2016.yaml
+++ b/configs/unbinned_v6/unbinned_2016.yaml
@@ -43,6 +43,18 @@ likelihood:
                 parameters: [c0, c1, c2, c3, c4, c5]
 
               systematics:
+                - id: Lumi_1516
+                  type: lnN
+                  value: 0.0118
+                  parameters: [nu_lumi_1516]
+                - id: Lumi_151617
+                  type: lnN
+                  value: 0.0004
+                  parameters: [nu_lumi_151617]
+                - id: Lumi_15161718
+                  type: lnN
+                  value: 0.0035
+                  parameters: [nu_lumi_15161718]              
                 - id: L1Prefire
                   type: pnn
                   job: pnn_TTLep_pow_2016_L1Prefire
diff --git a/configs/unbinned_v6/unbinned_2016APV.yaml b/configs/unbinned_v6/unbinned_2016APV.yaml
index 90c15e9..b86551b 100644
--- a/configs/unbinned_v6/unbinned_2016APV.yaml
+++ b/configs/unbinned_v6/unbinned_2016APV.yaml
@@ -43,6 +43,18 @@ likelihood:
                 parameters: [c0, c1, c2, c3, c4, c5]
 
               systematics:
+                - id: Lumi_1516
+                  type: lnN
+                  value: 0.0118
+                  parameters: [nu_lumi_1516]
+                - id: Lumi_151617
+                  type: lnN
+                  value: 0.0004
+                  parameters: [nu_lumi_151617]
+                - id: Lumi_15161718
+                  type: lnN
+                  value: 0.0035
+                  parameters: [nu_lumi_15161718]              
                 - id: L1Prefire
                   type: pnn
                   job: pnn_TTLep_pow_2016APV_L1Prefire
diff --git a/configs/unbinned_v6/unbinned_2017.yaml b/configs/unbinned_v6/unbinned_2017.yaml
index f0c83d4..aa2ae4b 100644
--- a/configs/unbinned_v6/unbinned_2017.yaml
+++ b/configs/unbinned_v6/unbinned_2017.yaml
@@ -43,6 +43,14 @@ likelihood:
                 parameters: [c0, c1, c2, c3, c4, c5]
 
               systematics:
+                - id: Lumi_151617
+                  type: lnN
+                  value: 0.0055
+                  parameters: [nu_lumi_151617]
+                - id: Lumi_15161718
+                  type: lnN
+                  value: 0.0061
+                  parameters: [nu_lumi_15161718]              
                 - id: L1Prefire
                   type: pnn
                   job: pnn_TTLep_pow_2017_L1Prefire
diff --git a/configs/unbinned_v6/unbinned_2018.yaml b/configs/unbinned_v6/unbinned_2018.yaml
index 51ac3e9..e0308d5 100644
--- a/configs/unbinned_v6/unbinned_2018.yaml
+++ b/configs/unbinned_v6/unbinned_2018.yaml
@@ -43,6 +43,10 @@ likelihood:
                 parameters: [c0, c1, c2, c3, c4, c5]
 
               systematics:
+                - id: Lumi_15161718
+                  type: lnN
+                  value: 0.0084
+                  parameters: [nu_lumi_15161718]              
                 - id: L1Prefire
                   type: pnn
                   job: pnn_TTLep_pow_2018_L1Prefire
diff --git a/data/RDataLoader.py b/data/RDataLoader.py
index 94da8c6..3ad6bfb 100644
--- a/data/RDataLoader.py
+++ b/data/RDataLoader.py
@@ -150,6 +150,13 @@ def __init__(
             for it in items:
                 self.addSelection(it)
 
+    def set_max_files( self, max_files ):
+        self._all_files = self._all_files[: int(max_files)]
+        # Split layout
+        if self.splitting_strategy not in ("files", "events"):
+            raise ValueError("splitting_strategy must be 'files' or 'events'")
+        self._file_splits: List[List[str]] = self._make_file_splits(self._all_files, self.n_split)
+
     # ----------------------- selections -----------------------
     def addSelection(
         self,
diff --git a/data/samples_RunII.py b/data/samples_RunII.py
index 8de74fd..fd1265d 100644
--- a/data/samples_RunII.py
+++ b/data/samples_RunII.py
@@ -16,11 +16,13 @@
 import observables
 from systematics_RunII import SYSTEMATICS
 import common.user as user
+from common.directories import (
+    DELPHES_TT2L_DIRECTORY,
+    SAMPLES_RUNII_BASE_DIRECTORY,
+)
 
 # Use Path so that BASE_DIRECTORY / "2018" / "file.root" works.
-BASE_DIRECTORY = Path(
-    "/groups/hephy/cms/robert.schoefbeck/CMGRDF_ntuples/v2-3-2_nJ2p_nB2p_2l/"
-)
+BASE_DIRECTORY = SAMPLES_RUNII_BASE_DIRECTORY
 ERAS = ["2016", "2016APV", "2017", "2018", "RunII"]
 
 GROUPS = {
@@ -42,49 +44,56 @@
 # -----------------------------
 # Base sample (nominal)
 # -----------------------------
-_base = RDataLoader(
-    input_paths=[
-        str(BASE_DIRECTORY / "2018" / "TTLep_pow_nominal.root"),
-    ],
-    tree_name="Events",
-    branches=(
-        observables.OBSERVERS
-        + observables.TOP_KINEMATICS
-        + observables.LEPTON_KINEMATICS
-        + observables.ASYMMETRY
-    ),
-    selection=None,
-    n_split=1,
-    splitting_strategy="events",
-    strict_branches=False,
-    weight_branches=[
-        "weight",
-        "L1PreFiringWeight_Nom",
-        "JetPUID_SF",
-        "Pileup_SF",
-        "btagSF_fixedWP_SF",
-        "lepEle_SF",
-        "lepMu_SF",
-    ],
-    feature_names=(
-        observables.TOP_KINEMATICS
-        + observables.LEPTON_KINEMATICS
-        + observables.ASYMMETRY
-    ),
-    observer_names=observables.OBSERVERS,
-)
-#FIXME The RDataloader should allow string based selections already in the constructor. Also, & binds stronger than &&!!! So parenthesis are needed.
-_base.addSelection( "(lep1_pt>20) & (tr_isvalid>0) & (isOS>0) & (offZ>0)", required_branches = ["lep1_pt", "isOS", "offZ", "tr_isvalid"]) 
+_base = None
+
+
+def _get_base() -> RDataLoader:
+    global _base
+    if _base is None:
+        _base = RDataLoader(
+            input_paths=[
+                str(BASE_DIRECTORY / "2018" / "TTLep_pow_nominal.root"),
+            ],
+            tree_name="Events",
+            branches=(
+                observables.OBSERVERS
+                + observables.TOP_KINEMATICS
+                + observables.LEPTON_KINEMATICS
+                + observables.ASYMMETRY
+            ),
+            selection=None,
+            n_split=1,
+            splitting_strategy="events",
+            strict_branches=False,
+            weight_branches=[
+                "weight",
+                "L1PreFiringWeight_Nom",
+                "JetPUID_SF",
+                "Pileup_SF",
+                "btagSF_fixedWP_SF",
+                "lepEle_SF",
+                "lepMu_SF",
+            ],
+            feature_names=(
+                observables.TOP_KINEMATICS
+                + observables.LEPTON_KINEMATICS
+                + observables.ASYMMETRY
+            ),
+            observer_names=observables.OBSERVERS,
+        )
+        # FIXME The RDataloader should allow string based selections already in
+        # the constructor. Also, & binds stronger than &&!!! So parenthesis are
+        # needed.
+        _base.addSelection(
+            "(lep1_pt>20) & (tr_isvalid>0) & (isOS>0) & (offZ>0)",
+            required_branches=["lep1_pt", "isOS", "offZ", "tr_isvalid"],
+        )
+    return _base
 
 delphes_OBSERVERS = ["Generator_x1", "Generator_x2", "Generator_id1", "Generator_id2", "Generator_scalePDF", "tr_isvalid", "run", "luminosityBlock", "event"]
 tt2l_delphes = RDataLoader( 
         input_paths=[ 
-            "/scratch-cbe/users/robert.schoefbeck/TT2lUnbinned/nanoTuples/delphes/v1/TTLep_pow_selected/",
-            #"/scratch-cbe/users/robert.schoefbeck/TT2lUnbinned/nanoTuples/delphes/v1/TTLep_pow_selected/TTLep_pow_0.root",
-            #"/scratch-cbe/users/robert.schoefbeck/TT2lUnbinned/nanoTuples/delphes/v1/TTLep_pow_selected/TTLep_pow_1.root",
-            #"/scratch-cbe/users/robert.schoefbeck/TT2lUnbinned/nanoTuples/delphes/v1/TTLep_pow_selected/TTLep_pow_2.root",
-            #"/scratch-cbe/users/robert.schoefbeck/TT2lUnbinned/nanoTuples/delphes/v1/TTLep_pow_selected/TTLep_pow_3.root",
-            #"/scratch-cbe/users/robert.schoefbeck/TT2lUnbinned/nanoTuples/delphes/v1/TTLep_pow_selected/TTLep_pow_4.root",
+            str(DELPHES_TT2L_DIRECTORY),
             ],
     tree_name="Events",
     branches=(
@@ -237,7 +246,7 @@ def _make_variation(process: str, era: str, tag: str, BASE_DIRECTORY: str = BASE
             )
         rootfiles.append(str(rootfile))
 
-    return _base.clone_from_files(rootfiles)
+    return _get_base().clone_from_files(rootfiles)
 
 def _make_group_variation(group: str, era: str, tag: str, BASE_DIRECTORY: str = BASE_DIRECTORY) -> RDataLoader:
     """
@@ -288,7 +297,7 @@ def _make_group_variation(group: str, era: str, tag: str, BASE_DIRECTORY: str =
             )
 
     # Clone base loader using all member files
-    return _base.clone_from_files(existing)
+    return _get_base().clone_from_files(existing)
 
 # ----------------------------------------------------------------------
 # Module-level __getattr__: lazy instantiation for all samples
@@ -512,4 +521,3 @@ def get(self, process: str, era: str = None, tag: str = None) -> RDataLoader:
     print("Base:", tt2l_delphes)
     F,O,W = tt2l_delphes.materialize(0,"fow")
     print("Shapes:", F.shape, O.shape, W.shape)
-

From d8addbef8aeab2c772a9d948cf35666b8e947c30 Mon Sep 17 00:00:00 2001
From: Ricardo Barrue <ricardo.barrue@cern.ch>
Date: Thu, 23 Apr 2026 12:10:05 +0200
Subject: [PATCH 16/17] Prefit plots from inputs: deleting broken + moving from
 Robert's folder

---
 plot/prefitsys/plot_from_inputs.py            | 1102 -----------------
 .../prefitsys}/prefit_sys_binned.py           |    0
 .../prefitsys}/prefit_sys_binned.sh           |    0
 {user/robert => plot/prefitsys}/variations.py |    0
 4 files changed, 1102 deletions(-)
 delete mode 100644 plot/prefitsys/plot_from_inputs.py
 rename {user/robert => plot/prefitsys}/prefit_sys_binned.py (100%)
 rename {user/robert => plot/prefitsys}/prefit_sys_binned.sh (100%)
 rename {user/robert => plot/prefitsys}/variations.py (100%)

diff --git a/plot/prefitsys/plot_from_inputs.py b/plot/prefitsys/plot_from_inputs.py
deleted file mode 100644
index 64d086c..0000000
--- a/plot/prefitsys/plot_from_inputs.py
+++ /dev/null
@@ -1,1102 +0,0 @@
-"""
-Script to create pre-fit variation plots directly from raw ±1σ input files.
-
-Generates two types of plots:
-1. Binned template comparisons: nominal vs up/down variations for each uncertainty
-2. Pre-fit stacks: combined samples with uncertainty bands, summed in quadrature
-
-Arguments:
-    --selection, -s: String-based selection in Python/Awkward format (e.g. use & instead of &&)
-    --version, -v: Version tag to append to output directories
-    --debug, -d: Enable debug mode (uses only 2016/2016APV era, one uncertainty per type, two features)
-"""
-
-import os, sys
-import gc # explicit garbage collection to avoid ridiculous (+100GB) memory usage
-import itertools
-import re
-import argparse as ap
-from typing import Sequence, Optional
-import time
-import logging
-
-import ROOT
-ROOT.gStyle.SetOptStat(0)
-ROOT.gROOT.SetBatch(1)
-
-import data.samples_RunII as samples
-from data.plot_options import plot_options
-
-import common.user as user
-import common.syncer as syncer
-import common.helpers as helpers
-
-import numpy as np
-
-import copy
-
-# NB: this is a first prototype and hasn't been fully battle tested
-def get_branches_for_selection(selection: str) -> Sequence[str]:
-    
-    # NB: the order matters, operators with more chars should be removed first
-    comparison_operators = ["==","!=",">=","<=",">","<","&","|","(",")"]
-
-    string_no_comparisons = selection
-    for operator in comparison_operators:
-        
-        # adding space to avoid variables sticking together in situations like "x>y" -> "xy"
-        string_no_comparisons = string_no_comparisons.replace(operator," ")
-    
-    branches_for_selection = []
-    for string in string_no_comparisons.split():
-
-        if string.isdigit() or (string in branches_for_selection):
-            continue
-        
-        # to take into account cuts with abs()
-        # should only require branches inside abs()
-        if 'abs' in string:
-            continue
-
-        branches_for_selection.append(string)
-
-    return branches_for_selection
-
-"""
-systematics are divided into three categories:
-- variations in weights which are part of overall weight - should replace nominal weight
-- additional weights, to be multiplied by the overall weight
-- kinematic variations - come from different files
-
-the RDataLoader access will be different for each
-"""
-
-"""
-variations in weights which are part of overall weight in nominal sample.
-should replace nominal weight by down or up variations
-
-structure:
-
-{group name: 
-    variation name: [nominal branch name, down variation branch name, up variation branch name]
-}
-"""
-replace_weight_groups = {
-    'EXPERIMENTAL': {
-        'L1Prefire': ['L1PreFiringWeight_Nom','L1PreFiringWeight_Dn','L1PreFiringWeight_Up'],
-        'PU' : ['Pileup_SF','Pileup_SFDn','Pileup_SFUp'],
-        'MuSF': ['lepMu_SF','lepMu_SFDn','lepMu_SFUp'],
-        'EleSF': ['lepEle_SF','lepEle_SFDn','lepEle_SFUp'],
-        'BTag_b_correlated': ['btagSF_fixedWP_SF','btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFDn',
-                              'btagSF_fixedWP_SF__CMS_eff_b_correlated_heavy_SFUp'],
-        # TODO: add this line when the quantities are added back into make_ntuple
-        # 'BTag_b_uncorrelated_<ERA>': ['btagSF_fixedWP_SF', 'btagSF_fixedWP_SF__CMS_eff_b_uncorrelated_<ERA>_heavy_SFDn',
-        #                               'btagSF_fixedWP_SF__CMS_eff_b_uncorrelated_<ERA>_heavy_SFUp'],
-        'BTag_l': ['btagSF_fixedWP_SF', 'btagSF_fixedWP_SF__CMS_eff_b_light_SFDn', 'btagSF_fixedWP_SF__CMS_eff_b_light_SFUp'],
-    }
-}
-
-
-"""
-additional weight to be multiplied by the overall weight of nominal sample. structure:
-
-{group name: 
-    variation name: [down variation branch name, up variation branch name]
-}
-"""
-add_weight_groups = {
-    'MODELING': { 
-        'mu_ren': ['scale_ren0p5_fac1p0','scale_ren2p0_fac1p0'],
-        'mu_fac': ['scale_ren1p0_fac0p5','scale_ren1p0_fac2p0'],
-        'ShowerISR': ['shower_isr0p5_fsr1p0', 'shower_isr2p0_fsr1p0'], 
-        'ShowerFSR': ['shower_isr1p0_fsr0p5', 'shower_isr1p0_fsr2p0'],
-        'AlphaS': ['pdf_alphas_dn','pdf_alphas_up']
-    },
-}
-
-"""
-file directories and names follow the structure {era}/{sample}_{tag}
-different sample with kinematic variations. structure:
-
-{group name: 
-    variation name: [down variation file tag, up variation file tag]
-}
-
-"""
-kinematic_variation_groups = {
-        'JER': {
-            'CMS_res_j_0_<ERA>': ['CMS_res_j_0_<ERA>_down', 'CMS_res_j_0_<ERA>_up'],
-            'CMS_res_j_1_<ERA>': ['CMS_res_j_1_<ERA>_down', 'CMS_res_j_1_<ERA>_up'],
-            'CMS_res_j_2_<ERA>': ['CMS_res_j_2_<ERA>_down', 'CMS_res_j_2_<ERA>_up'],
-            'CMS_res_j_3_<ERA>': ['CMS_res_j_3_<ERA>_down', 'CMS_res_j_3_<ERA>_up'],
-            'CMS_res_j_4_<ERA>': ['CMS_res_j_4_<ERA>_down', 'CMS_res_j_4_<ERA>_up'],
-            'CMS_res_j_5_<ERA>': ['CMS_res_j_5_<ERA>_down', 'CMS_res_j_5_<ERA>_up'],
-        },
-        'JES1': {
-            'CMS_scale_j_FlavorPureBottom': ['CMS_scale_j_FlavorPureBottom_down', 'CMS_scale_j_FlavorPureBottom_up'],
-            'CMS_scale_j_FlavorPureCharm': ['CMS_scale_j_FlavorPureCharm_down', 'CMS_scale_j_FlavorPureCharm_up'],
-            'CMS_scale_j_FlavorPureGluon': ['CMS_scale_j_FlavorPureGluon_down', 'CMS_scale_j_FlavorPureGluon_up'],
-            'CMS_scale_j_FlavorPureQuark': ['CMS_scale_j_FlavorPureQuark_down', 'CMS_scale_j_FlavorPureQuark_up'],
-        },
-        'JES2': {
-            'CMS_scale_j_Regrouped_Absolute': ['CMS_scale_j_Regrouped_Absolute_down', 'CMS_scale_j_Regrouped_Absolute_up'],
-            'CMS_scale_j_Regrouped_Absolute_<ERA>': ['CMS_scale_j_Regrouped_Absolute_<ERA>_down', 'CMS_scale_j_Regrouped_Absolute_<ERA>_up'],
-            'CMS_scale_j_Regrouped_BBEC1': ['CMS_scale_j_Regrouped_BBEC1_down', 'CMS_scale_j_Regrouped_BBEC1_up'],
-            'CMS_scale_j_Regrouped_BBEC1_<ERA>': ['CMS_scale_j_Regrouped_BBEC1_<ERA>_down', 'CMS_scale_j_Regrouped_BBEC1_<ERA>_up'],
-            'CMS_scale_j_Regrouped_EC2': ['CMS_scale_j_Regrouped_EC2_down', 'CMS_scale_j_Regrouped_EC2_up'],
-            'CMS_scale_j_Regrouped_EC2_<ERA>': ['CMS_scale_j_Regrouped_EC2_<ERA>_down', 'CMS_scale_j_Regrouped_EC2_<ERA>_up'],
-        },
-        'JES3': {
-            'CMS_scale_j_Regrouped_HF': ['CMS_scale_j_Regrouped_HF_down','CMS_scale_j_Regrouped_HF_up'],
-            'CMS_scale_j_Regrouped_RelativeBal': ['CMS_scale_j_Regrouped_RelativeBal_down','CMS_scale_j_Regrouped_RelativeBal_up'],
-            'CMS_scale_j_Regrouped_RelativeSample_<ERA>': ['CMS_scale_j_Regrouped_RelativeSample_<ERA>_down','CMS_scale_j_Regrouped_RelativeSample_<ERA>_up'],
-            'Uncl': ['Uncl_down', 'Uncl_up'],
-        },
-}
-
-# returns bin edges in Numpy format (low edges + upper edge of last bin)
-def get_bin_edges(feature_name: str, print_add_info = False) -> Optional[Sequence[float]]:
-    
-    if feature_name in plot_options:
-        
-        # prioritize set of bin edges for pre-fit plots
-        # to have plots similar to TOP-20-006
-        if 'bin_edges' in plot_options[feature_name]:
-            # gets thresholds directly from plot_options
-            edges = plot_options[feature_name]['bin_edges']
-            if print_add_info:
-                logger.info(f"Using bin edges from plot_options for '{feature_name}': {edges}")
-        
-        elif 'binning' in plot_options[feature_name]:
-            # build thresholds from plot_options: [nBins, low, high]
-            nBins, low, high = plot_options[feature_name]['binning']
-            edges = [low + i*(high - low) / nBins for i in range(nBins + 1)]
-            if print_add_info:
-                logger.info(f"Using equidistant binning from plot_options for '{feature_name}': "
-                f"nBins={nBins}, low={low}, high={high} -> {len(edges)-1} bins.")
-        
-        return edges
-    
-    else:
-        return None
-    
-if __name__ == "__main__":
-
-    logging.basicConfig(format='%(levelname)s: %(message)s',level=logging.INFO)
-    logger = logging.getLogger(__name__)
-
-    parser = ap.ArgumentParser(description='make plots of pre-fit variations directly from raw +-1 sigma input files, instead of using ICPH surrogates')
-    parser.add_argument('--selection', '-s', type=str, help='string-based selection in Python/Awkward format, e.g. use & instead of && for chaining selections')
-    parser.add_argument('--version', '-v', help = 'version, to be added to the relevant directories')
-    parser.add_argument('--debug', '-d', help = 'enables debug mode, keeping only era and one uncertainty of each type', action="store_true")
-
-    args = parser.parse_args()
-
-    samples_to_use = ['TTLep_pow', 'TTSemi_pow', 'SingleTop', 'DrellYan']
-    eras = samples.ERAS
-
-    selection = args.selection
-    debug = args.debug
-    version = args.version
-
-    if debug:
-        logger.info("Debug mode: printing additional information, plotting 2016 and 2016APV only, only using one of each type of uncertainty and only plotting two features.")
-        logger.setLevel(logging.DEBUG)
-        eras = ["2016","2016APV"]
-        replace_weight_groups = {'EXPERIMENTAL': {'L1Prefire': ['L1PreFiringWeight_Nom','L1PreFiringWeight_Dn','L1PreFiringWeight_Up']}}
-        add_weight_groups = {'MODELING': {'mu_ren': ['scale_ren0p5_fac1p0','scale_ren2p0_fac1p0']}}
-        kinematic_variation_groups = {'JER': {'CMS_res_j_0_<ERA>': ['CMS_res_j_0_<ERA>_down', 'CMS_res_j_0_<ERA>_up']},
-                                      'JES2': {'CMS_scale_j_Regrouped_Absolute_<ERA>': ['CMS_scale_j_Regrouped_Absolute_<ERA>_down', 'CMS_scale_j_Regrouped_Absolute_<ERA>_up']}}
-
-    if selection:
-        if "abs" in selection and not (("np.abs" in selection) or ("ak.abs" not in selection)):
-            logger.warning("selection requires absolute values using abs, replacing by np.abs")
-            selection.replace("abs","np.abs")
-            
-        requested_branches_for_selection = get_branches_for_selection(selection)
-        logger.info(f"{selection=}, {requested_branches_for_selection=}")
-
-    if version:
-        logger.info(f"Writing plots under sub-directories with name {version}")
-
-    """
-    stores histograms of nominal, up and down variations
-    for each era, sample, feature, uncertainty set
-    
-    used to separate creation of RDataLoaders,
-    fetching of templates for each uncertainty
-    from creation of pre-fit binned template comparisons and stacks
-    
-    structure of dictionary:
-    {
-        era: {
-            sample: {
-                feature: {
-                    uncertainty: [nominal, down variation template, up variation templates]
-                }
-            }
-        }
-    }
-    """
-
-    # initializing here to avoid adding another layer of for loop separating era and sample
-    histogram_dict = {}
-    for era in eras:
-        histogram_dict[era] = {}
-        for sample in samples_to_use:
-            histogram_dict[era][sample] = {}
-
-    # used to have a simple way to iterate over all the features
-    # once the nominal sample object is deleted
-    list_features = []
-
-    for i_era_sample, (era, sample) in enumerate(itertools.product(eras, samples_to_use)):
-        print(f"era: {era}, sample: {sample}")
-        
-        nominal_sample = getattr(samples, f'{sample}_{era}_nominal')
-        
-        # initializating dict here to avoid bugs
-        for i_feature, feature_name in enumerate(nominal_sample.feature_names):
-
-            if debug and i_feature > 1:
-                continue
-            
-            histogram_dict[era][sample][feature_name] = {}
-
-            # simple way to let us know the binning only once and not pollute the terminal
-            if i_era_sample==0:
-                get_bin_edges(feature_name, print_add_info=True)
-                list_features.append(feature_name)
-
-        t0 = time.perf_counter()
-
-        if selection:
-            nominal_sample.addSelection(selection, requested_branches_for_selection)
-
-        dt0 = time.perf_counter() - t0
-        logger.debug(f"time to add selections on nominal sample: {dt0:.6f} s")
-
-        t1 = time.perf_counter()
-        # this could be replaced by opening the files, and issuing a TTree->Draw command (optimized)
-        nominal_feature_values, nominal_weights = nominal_sample.materialize(0, what='fw')
-
-        dt1 = time.perf_counter() - t1
-        logger.debug(f"time to materialize nominal sample: {dt1:.6f} s")
-
-        t2 = time.perf_counter()
-
-        # list of weights in nominal sample
-        weight_names = nominal_sample.weight_branches
-
-        """
-        To take into account the three types of handling systematic variations
-        at the RDataLoader level
-        """
-        for mode in ["replace", "add", "kinematics"]:
-
-            if mode == "replace":
-                syst_groups = replace_weight_groups
-                if i_era_sample == 0:
-                    logger.info("plotting variations for scale factors which are part of the overall weight, " \
-                "e.g. pileup reweighting scale factor uncertainty")
-            elif mode == "add":
-                syst_groups = add_weight_groups
-                if i_era_sample == 0:
-                    logger.info("plotting variations implemented as scale factors which multiply the overall event weight, " \
-                "e.g. QCD scale variations")
-            elif mode == "kinematics":
-                syst_groups = kinematic_variation_groups
-                if i_era_sample == 0:
-                    logger.info("plotting variations from varied kinematics (JME)")
-
-            for group, uncertainty_names in syst_groups.items():
-                if i_era_sample == 0:
-                    logger.info(f"group: {group}, uncertainties: {uncertainty_names.keys()}")
-
-                for uncertainty_name, branch_names in uncertainty_names.items():
-
-                    if i_era_sample == 0:
-                        logger.info(f"uncertainty name: {uncertainty_name}, branch names: {branch_names}")
-
-                    # logic different for each type of systematic variations
-                    if mode == "replace":
-                
-                        """
-                        For variations, cloning sample replacing nominal weight branch with varied one,
-                        since one can only change the weight branches at RDataLoader creation.
-                        """
-                        treplace = time.perf_counter()
-                        # using structure defined in replace_weight_groups
-                        nominal_weight_name = branch_names[0]
-                        down_var_weight_name = branch_names[1]
-                        up_var_weight_name = branch_names[2]
-
-                        if '<ERA>' in uncertainty_name:
-                            uncertainty_name = uncertainty_name.replace('<ERA>',str(era))
-                            down_var_weight_name = down_var_weight_name.replace('<ERA>',str(era))
-                            up_var_weight_name = up_var_weight_name.replace('<ERA>',str(era))
-
-                        weight_names_varied = weight_names
-                        weight_to_remove_idx = weight_names_varied.index(nominal_weight_name)
-                        
-                        weight_names_varied[weight_to_remove_idx] = down_var_weight_name
-                        down_var_sample = nominal_sample.clone_from_files(nominal_sample.files, weight_names_varied)
-
-                        weight_names_varied[weight_to_remove_idx] = up_var_weight_name
-                        up_var_sample = nominal_sample.clone_from_files(nominal_sample.files, weight_names_varied)
-
-                        # fixes cases where there are two uncertainties with the same
-                        # nominal weight name (e.g. b-tag SF)
-                        weight_names_varied[weight_to_remove_idx] = nominal_weight_name
-
-                        dtreplace_clone_files = time.perf_counter() - treplace
-                        logger.debug(f"time to edit era strings and clone files for replace-type alternative sample: {dtreplace_clone_files:.6f} s")
-
-                        down_var_weights = down_var_sample.materialize(0, what='w')[0]
-                        up_var_weights = up_var_sample.materialize(0, what='w')[0]
-
-                        # doing this to have a generic assignment outside of "if" condition
-                        down_var_feature_values = nominal_feature_values
-                        up_var_feature_values = nominal_feature_values
-                        
-                        dtreplace = time.perf_counter() - treplace - dtreplace_clone_files
-                        logger.debug(f"time to materialize weights from replace-type alternative samples: {dtreplace:.6f} s")
-                    
-                    elif mode == "add":
-                
-                        tadd = time.perf_counter()
-                        """
-                        For variations, cloning nominal sample add branch for variation varied one,
-                        since one can only change the weight branches at RDataLoader creation.
-                        """
-
-                        # using structure defined in add_weight_groups
-                        down_var_weight_name = branch_names[0]
-                        up_var_weight_name = branch_names[1]
-
-                        if '<ERA>' in uncertainty_name:
-                            uncertainty_name = uncertainty_name.replace('<ERA>',str(era))
-                            down_var_weight_name = down_var_weight_name.replace('<ERA>',str(era))
-                            up_var_weight_name = up_var_weight_name.replace('<ERA>',str(era))                        
-                        
-                        down_var_sample = nominal_sample.clone_from_files(nominal_sample.files, weight_names+[down_var_weight_name])
-                        up_var_sample = nominal_sample.clone_from_files(nominal_sample.files, weight_names+[up_var_weight_name])
-
-                        dtadd_clone_files = time.perf_counter() - tadd
-                        logger.debug(f"time to edit era strings and clone files for add-type alternative sample: {dtadd_clone_files:.6f} s")
-
-                        down_var_weights = down_var_sample.materialize(0, what='w')[0]
-                        down_var_feature_values = nominal_feature_values
-                        
-                        up_var_weights = up_var_sample.materialize(0, what='w')[0]
-                        up_var_feature_values = nominal_feature_values
-
-                        dtadd = time.perf_counter() - tadd - dtadd_clone_files
-                        logger.debug(f"time to materialize weights from add-type alternative samples: {dtadd:.6f} s")
-
-                    elif mode == "kinematics":
-                        
-                        tkin = time.perf_counter()
-                        """
-                        For kinematic variations, cloning from different files, keeping the same branch names,
-                        since one can only change the weight branches at RDataLoader creation.
-                        """
-
-                        # using structure defined in add_weight_groups
-                        down_var_file_tag = branch_names[0]
-                        up_var_file_tag = branch_names[1]
-
-                        if '<ERA>' in uncertainty_name:
-                            uncertainty_name = uncertainty_name.replace('<ERA>',str(era))
-                            down_var_file_tag = down_var_file_tag.replace('<ERA>',str(era))
-                            up_var_file_tag = up_var_file_tag.replace('<ERA>',str(era))
-
-                        # all era-decorrelated JES variations consider 2016 and 2016APV as single 2016 era
-                        # the opposite is true for JER variations
-                        if 'CMS_res_j' not in uncertainty_name:
-                            # uncertainty_name = uncertainty_name.replace("APV","")
-                            down_var_file_tag = down_var_file_tag.replace("APV","")
-                            up_var_file_tag = up_var_file_tag.replace("APV","")
-
-                        down_var_sample = getattr(samples, f'{sample}_{era}_{down_var_file_tag}')
-                        up_var_sample = getattr(samples, f'{sample}_{era}_{up_var_file_tag}')
-
-                        dtkin_get_files = time.perf_counter() - tkin
-                        logger.debug(f"time to edit era strings and fetch files for samples with kinematic variations: {dtkin_get_files:.6f} s")
-
-                        down_var_feature_values, down_var_weights = down_var_sample.materialize(0, what='fw')
-                        # parsing output of materialize into a simple array
-                        # also done when loading the nominal sample                        
-                        up_var_feature_values, up_var_weights = up_var_sample.materialize(0, what='fw')                        
-
-                        dtkin = time.perf_counter() - tkin - dtkin_get_files
-                        logger.debug(f"time to materialize kinematic-type alternative samples: {dtkin:.6f} s")
-
-                        # tkin_clean = time.perf_counter()
-                        
-                        # del down_var_feature_values, up_var_feature_values
-                        # gc.collect()
-                        
-                        # dtkin_clean = time.perf_counter() - tkin_clean
-                        # logger.debug(f"time to clean feature values from kinematic-type alternative sample: {dtkin_clean:.6f} s")
-
-
-                    for i_feature, feature_name in enumerate(nominal_sample.feature_names):
-
-                        if debug and i_feature > 1:
-                            continue
-
-                        edges = get_bin_edges(feature_name)
-                        
-                        if not edges:
-                            if i_era_sample == 0:
-                                logger.warning(f"feature {feature_name} does not have default binning in plot_options, skipping histogram filling")
-                            continue
-
-                        if i_era_sample == 0:
-                            logger.debug(f"{feature_name=}, {edges=}")
-                        
-                        nominal_hist_entries = np.histogram(a=nominal_feature_values[:,i_feature], bins=edges, weights=nominal_weights)[0]
-                        
-                        down_var_hist_entries = np.histogram(a=down_var_feature_values[:,i_feature], bins=edges, weights=down_var_weights)[0]
-                        up_var_hist_entries = np.histogram(a=up_var_feature_values[:,i_feature], bins=edges, weights=up_var_weights)[0]
-
-                        # converting Numpy histogram edges (low edges + upper edge of last bin)
-                        # to ROOT binning (lower edges only), bin 0 is underflow bin, bin nbins+1 is overflow
-                        n_bins = len(edges)-1
-
-                        # # central histogram with variable binning, created only once
-                        h_central_name = f"h_central_{era}_{sample}_{uncertainty_name}_{feature_name}"
-                        h_central = ROOT.TH1F(h_central_name, "", n_bins, np.array(edges, dtype=float))
-                        for i in range(n_bins):
-                            h_central.SetBinContent(i + 1, nominal_hist_entries[i])
-
-                        h_down_name = f"h_{era}_{sample}_{uncertainty_name}_{feature_name}_Down"
-                        h_down = ROOT.TH1F(h_down_name, "", n_bins, np.array(edges, dtype=float))
-                        for i in range(n_bins):
-                            h_down.SetBinContent(i + 1, down_var_hist_entries[i])
-
-                        h_up_name = f"h_{era}_{sample}_{uncertainty_name}_{feature_name}_Up"
-                        h_up = ROOT.TH1F(h_up_name, "", n_bins, np.array(edges, dtype=float))
-                        for i in range(n_bins):
-                            h_up.SetBinContent(i + 1, up_var_hist_entries[i])
-
-                        histogram_dict[era][sample][feature_name][uncertainty_name] = []
-
-                        histogram_dict[era][sample][feature_name][uncertainty_name].append(h_central)
-                        histogram_dict[era][sample][feature_name][uncertainty_name].append(h_down)
-                        histogram_dict[era][sample][feature_name][uncertainty_name].append(h_up)
-                        
-
-                    # t_clean = time.perf_counter()
-
-                    # del down_var_feature_values, up_var_feature_values
-                    # del down_var_weights, up_var_weights
-                    down_var_sample._arr_cache.clear()
-                    up_var_sample._arr_cache.clear()
-                    del down_var_sample, up_var_sample
-
-                    gc.collect()
-                    
-                    # dt_clean = time.perf_counter() - t_clean
-                    # logger.debug(f"time to do general memory clean from any alternative sample: {dt_clean:.6f} s")
-
-
-                # t_root_compare = time.perf_counter()
-
-                # dt_root_compare = time.perf_counter() - t_root_compare
-                # logger.debug(f"time to make the ROOT plot comparison: {dt_root_compare:.6f} s")
-
-        nominal_sample._arr_cache.clear()
-        del nominal_sample, nominal_feature_values, nominal_weights
-        gc.collect()
-
-        if i_era_sample == 0:
-            logger.info("after first sample/era combination, no longer printing variable/branch information")
-
-
-    logger.debug(histogram_dict)
-
-
-
-
-    """
-    ### Binned template comparisons ###
-
-    making binned template input comparisons from nominal, down and up variation templates from previous step
-
-    remember the structure of histogram_dict:
-        histogram_dict[era][sample][feature_name][uncertainty_name] = [h_nominal, h_down, h_up]
-    
-    """
-    # legend columns (configurable) - for binned template plots
-    legend_columns_binned_templates = 3
-
-    plot_directory_binned_templates = os.path.join(user.plot_directory, 'binned_templates_from_inputs')
-    if debug:
-        plot_directory_binned_templates = os.path.join(plot_directory_binned_templates,"debug")
-    elif version:
-        plot_directory_binned_templates = os.path.join(plot_directory_binned_templates,version)
-
-    logger.info(f"Creating binned templates from sample inputs, will be written under {plot_directory_binned_templates}")
-    os.makedirs(plot_directory_binned_templates, exist_ok=True)
-
-    # simple color palette
-    binned_template_colors = [
-        ROOT.kRed + 1,
-        ROOT.kBlue + 1,
-        ROOT.kGreen + 2,
-        ROOT.kMagenta + 1,
-        ROOT.kOrange + 1,
-        ROOT.kCyan + 1,
-    ]
-
-    # creating a single dictionary with all the uncertainty groups
-    uncertainty_groups = replace_weight_groups
-    uncertainty_groups.update(add_weight_groups)
-    uncertainty_groups.update(kinematic_variation_groups)
-
-    for i_era_sample, (era, sample) in enumerate(itertools.product(eras, samples_to_use)):
-
-        individual_plot_dir = os.path.join(plot_directory_binned_templates,era,sample)
-        os.makedirs(individual_plot_dir, exist_ok=True)
-        helpers.copyIndexPHP(individual_plot_dir)
-            
-        if i_era_sample == 0:
-            logger.info(f"{era=}, {sample=}")
-
-        for feature_name in list_features:
-
-            if i_era_sample == 0:
-                logger.info(f"{feature_name=}")
-
-            if feature_name not in plot_options:
-                if i_era_sample == 0:
-                    logger.warning(f"feature {feature_name} not in plot_options, skipping histogram")
-                continue
-
-            logY = plot_options.get(feature_name, {}).get('logY', False)
-            x_title = plot_options.get(feature_name, {}).get('tex', feature_name)
-            
-            for group, uncertainties in uncertainty_groups.items():
-                
-                canvas_name = f"{group}_{feature_name}_{era}_{sample}"
-                # stretch in y
-                c = ROOT.TCanvas(canvas_name, canvas_name, 800, 900)
-
-                # three pads: legend (top), yields (middle), ratios (bottom)
-                padLegend = ROOT.TPad(canvas_name + "_legend", canvas_name + "_legend", 0.0, 0.80, 1.0, 1.0)
-                padTop    = ROOT.TPad(canvas_name + "_top",    canvas_name + "_top",    0.0, 0.30, 1.0, 0.80)
-                padBottom = ROOT.TPad(canvas_name + "_bottom", canvas_name + "_bottom", 0.0, 0.00, 1.0, 0.30)
-
-                padLegend.SetBottomMargin(0.05)
-                padLegend.SetTopMargin(0.10)
-                padLegend.SetLeftMargin(0.10)
-                padLegend.SetRightMargin(0.10)
-                padLegend.SetFillStyle(0)
-
-                padTop.SetBottomMargin(0.)
-                padTop.SetTopMargin(0.08)
-                padTop.SetLeftMargin(0.10)
-                padTop.SetRightMargin(0.05)
-
-                padBottom.SetTopMargin(0.0)
-                padBottom.SetBottomMargin(0.30)
-                padBottom.SetLeftMargin(0.10)
-                padBottom.SetRightMargin(0.05)
-
-                padLegend.Draw()
-                padTop.Draw()
-                padBottom.Draw()
-
-                # legend (created here, drawn later in padLegend)
-                legend = ROOT.TLegend(0.02, 0.10, 0.98, 0.90)
-                legend.SetBorderSize(0)
-                legend.SetFillStyle(0)
-                legend.SetNColumns(legend_columns_binned_templates)
-
-                # ------------- TOP PAD: absolute yields -------------
-                padTop.cd()
-                padTop.SetTicks(1, 1)
-                if logY:
-                    padTop.SetLogy(True)
-
-                # collect all histograms to draw in the top pad, format them and draw them
-
-                first_uncertainty_in_group = list(uncertainties.keys())[0]
-                if '<ERA>' in first_uncertainty_in_group:
-                    first_uncertainty_in_group = first_uncertainty_in_group.replace('<ERA>',str(era))
-                
-                # collect and format central histogram
-                h_central = histogram_dict[era][sample][feature_name][first_uncertainty_in_group][0]
-                h_central.SetLineColor(ROOT.kBlack)
-                h_central.SetLineWidth(2)
-                # # no title on the top pad
-                h_central.SetTitle("")
-                h_central.GetXaxis().SetTitle(x_title)
-                h_central.GetYaxis().SetTitle("Events")
-                h_central.GetYaxis().SetTitleSize(0.06)
-                h_central.GetYaxis().SetLabelSize(0.045)
-                # # x label on bottom pad only
-                h_central.GetXaxis().SetLabelSize(0)
-                h_central.GetXaxis().SetTitleSize(0)
-
-                legend.AddEntry(h_central, "Nominal", "l")
-
-                # storing nominal and variation histograms to draw in same canvas
-                # since these will be looped over several times
-                h_variations = [h_central]
-
-                color_index = 0
-                for uncertainty_name in uncertainties:
-
-                    if '<ERA>' in uncertainty_name:
-                        uncertainty_name = uncertainty_name.replace('<ERA>',str(era))
-
-                    color = binned_template_colors[color_index % len(binned_template_colors)]
-
-                    h_down = histogram_dict[era][sample][feature_name][uncertainty_name][1]
-                    h_down.SetLineColor(color)
-                    h_down.SetLineStyle(ROOT.kDashed)
-                    h_down.SetLineWidth(1)
-                    
-                    h_up = histogram_dict[era][sample][feature_name][uncertainty_name][2]
-                    h_up.SetLineColor(color)
-                    h_up.SetLineStyle(ROOT.kSolid)
-                    h_up.SetLineWidth(1)
-                    
-                    # remove unnecessary "CMS_" tag from name
-                    uncertainty_name_for_plot = uncertainty_name.replace("CMS_","") 
-                    legend.AddEntry(h_down, f"{uncertainty_name_for_plot} -1#sigma","l")
-                    legend.AddEntry(h_up, f"{uncertainty_name_for_plot} +1#sigma","l")
-
-                    h_variations.append(h_down)
-                    h_variations.append(h_up)
-
-                    color_index += 1
-
-                # getting reasonable y range (absolute yields)
-                max_y = max(h.GetMaximum() for h in h_variations)
-                if logY:
-                    h_central.SetMinimum(0.8)
-                    h_central.SetMaximum(1.2 * max_y if max_y > 0 else 1.0)
-                else:
-                    h_central.SetMinimum(0.0)
-                    h_central.SetMaximum(1.2 * max_y if max_y > 0 else 1.0)                    
-
-                h_central.Draw("HIST")
-
-                for h in h_variations[1:]:
-                    h.Draw("HIST SAME")
-
-                # ------------- BOTTOM PAD: ratios -------------
-                padBottom.cd()
-                padBottom.SetTicks(1, 1)
-
-                # ratio central
-                ratio_central_name = h_central.GetName() + "_ratio"
-                h_ratio_central = h_central.Clone(ratio_central_name)
-                h_ratio_central.SetDirectory(0)
-                h_ratio_central.Divide(h_central)
-                h_ratio_central.SetLineColor(ROOT.kBlack)
-                h_ratio_central.SetLineWidth(2)
-                h_ratio_central.SetTitle("")
-
-                h_ratio_central.GetYaxis().SetTitle("var / nominal")
-                h_ratio_central.GetYaxis().SetNdivisions(505)
-                h_ratio_central.GetYaxis().SetTitleSize(0.09)
-                h_ratio_central.GetYaxis().SetTitleOffset(0.5)
-                h_ratio_central.GetYaxis().SetLabelSize(0.08)
-
-                h_ratio_central.GetXaxis().SetTitle(x_title)
-                h_ratio_central.GetXaxis().SetTitleSize(0.1)
-                h_ratio_central.GetXaxis().SetLabelSize(0.08)
-
-                # build ratio histos for variations
-                h_ratio_vars = [h_ratio_central]
-                for h in h_variations[1:]:
-                    r_name = h.GetName() + "_ratio"
-                    h_r = h.Clone(r_name)
-                    h_r.SetDirectory(0)
-                    h_r.Divide(h_central)
-                    h_ratio_vars.append(h_r)
-
-                # ratio y-range based on max relative deviation from 1
-                max_dev = 0.0
-                for h in h_ratio_vars:
-                    for i in range(1, n_bins+1):
-                        val = h.GetBinContent(i)
-                        if val != 0:
-                            dev = abs(val - 1.0)
-                            if dev > max_dev:
-                                max_dev = dev
-
-                if max_dev <= 0.0:
-                    r_min, r_max = 0.9, 1.1
-                else:
-                    # 30% larger than max deviation, symmetric around 1
-                    half_range = 1.3 * max_dev
-                    r_min = 1.0 - half_range
-                    r_max = 1.0 + half_range
-
-                h_ratio_central.SetMinimum(max(r_min,-2.0))
-                h_ratio_central.SetMaximum(min(r_max,2.0))
-
-                h_ratio_central.Draw("HIST")
-                for h_r in h_ratio_vars[1:]:
-                    h_r.Draw("HIST SAME")
-
-                # line at 1
-                line = ROOT.TLine(edges[0], 1.0, edges[-1], 1.0)
-                line.SetLineStyle(ROOT.kDashed)
-                line.SetLineColor(ROOT.kBlack)
-                line.Draw("SAME")
-
-                # ------------- LEGEND PAD -------------
-                padLegend.cd()
-                # no frame, no axes, just the legend
-                legend.Draw()
-
-                ## Saving histograms
-                c.cd()
-                c.Update()
-
-                out_png = os.path.join(individual_plot_dir, canvas_name + ".png")
-                out_pdf = os.path.join(individual_plot_dir, canvas_name + ".pdf")
-                c.SaveAs(out_png)
-                c.SaveAs(out_pdf)
-
-    
-    """
-    making pre-fit stacks from nominal, up and down variation templates from previous step
-
-    sums variations for each sample in quadrature separately for up and down variations
-    sets symmetric uncertainty in each bin of combined histogram as max(up, down) for that bins
-
-    follows very closely the structure in plot.py
-
-    remember the structure of histogram_dict:
-        histogram_dict[era][sample][feature_name][uncertainty_name] = [h_nominal, h_down, h_up]
-    """
-
-    plot_directory_stacks = os.path.join(user.plot_directory, 'prefit_stacks_from_inputs')
-    if debug:
-        plot_directory_stacks = os.path.join(plot_directory_stacks,"debug")
-    elif version:
-        plot_directory_stacks = os.path.join(plot_directory_stacks,version)        
-
-    # logger.info(f"Pre-fit stacks saved to folder {plot_directory_stacks}")
-    from data.colors import get_color
-
-    legend_columns_prefit_stacks = 2
-
-    for era in eras:
-        
-        for feature_name in list_features:
-
-            edges = get_bin_edges(feature_name)
-            
-            # this situation will likely never happen
-            # but keeping the safety here
-            if not edges:
-                continue
-
-            logY = plot_options.get(feature_name, {}).get('logY', False)
-            x_title = plot_options.get(feature_name, {}).get('tex', feature_name)        
-
-            # converting Numpy histogram edges (low edges + upper edge of last bin)
-            # to ROOT binning (lower edges only), bin 0 is underflow bin, bin nbins+1 is overflow
-            n_bins = len(edges)-1
-
-            # sample_histogram_dict = histogram_dict[era]
-
-            # build total histogram and each of the variations
-            h_total = ROOT.TH1F(f"h_prefit_total_{era}","", n_bins, np.array(edges, dtype=float))
-            h_unc_down = ROOT.TH1F(f"h_prefit_unc_down_{era}","", n_bins, np.array(edges, dtype=float))
-            h_unc_up = ROOT.TH1F(f"h_prefit_unc_up_{era}","", n_bins, np.array(edges, dtype=float))
-            
-            # nominal histogram is the same for all the different uncertainties
-            # convoluted way to fetch the nominal histogram but it works
-            first_uncertainty = list(histogram_dict[era][samples_to_use[0]][feature_name].keys())[0]
-            if '<ERA>' in first_uncertainty:
-                first_uncertainty = first_uncertainty.replace('<ERA>',str(era))
-            
-            for sample in samples_to_use:
-                
-                h_nominal = histogram_dict[era][sample][feature_name][first_uncertainty][0]
-                h_total.Add(h_nominal)
-                
-                uncertainty_histogram_dict = histogram_dict[era][sample][feature_name]
-
-                for i_uncertainty, (uncertainty, histograms) in enumerate(uncertainty_histogram_dict.items()):
-                    
-                    # creating histograms with uncertainties
-                    # summing in quadrature each of the variations
-                    down_variation_histo = histograms[1]
-                        
-                    h_var_down = down_variation_histo - h_nominal
-                    h_var_down.Multiply(h_var_down)
-                    h_unc_down.Add(h_var_down)
-
-                    up_variation_histo = histograms[2]
-
-                    h_var_up = up_variation_histo - h_nominal
-                    h_var_up.Multiply(h_var_up)
-                    h_unc_up.Add(h_var_up)
-
-            # uncertainty band via TBoxes + line-only histos
-            uncertainty_boxes = []
-
-            h_line_up   = h_total.Clone(f"h_prefit_up_{era}")
-            h_line_down = h_total.Clone(f"h_prefit_down_{era}")
-
-            # lines only, no fill
-            h_line_up.SetFillStyle(0)
-            h_line_up.SetFillColor(0)
-            h_line_down.SetFillStyle(0)
-            h_line_down.SetFillColor(0)
-            h_line_up.SetLineColor(ROOT.kGray + 2)
-            h_line_down.SetLineColor(ROOT.kGray + 2)
-            h_line_up.SetLineWidth(1)
-            h_line_down.SetLineWidth(1)
-
-            logger.debug(f"Creating uncertainty boxes.")
-
-            for ib in range(1, n_bins+1):
-                x1 = edges[ib-1]
-                x2 = edges[ib]
-                nom = h_total.GetBinContent(ib)
-                err_up = np.sqrt(h_unc_up.GetBinContent(ib))
-                err_down = np.sqrt(h_unc_down.GetBinContent(ib))
-
-                if nom > 0.0:
-                    y_low  = nom - err_down
-                    y_high = nom + err_up
-                    logger.debug(f"{ib=}, {nom=}, {y_low=}, {y_high=}, {(y_low/nom)=}, {(y_high/nom)=}")
-
-                    box = ROOT.TBox(x1, y_low, x2, y_high)
-                    box.SetFillColor(ROOT.kGray + 1)
-                    box.SetFillStyle(3345)
-                    box.SetLineWidth(0)
-                    uncertainty_boxes.append(box)
-
-                    h_line_up.SetBinContent(ib, y_high)
-                    h_line_down.SetBinContent(ib, y_low)
-                else:
-                    # no prediction in this bin -> keep lines at 0
-                    h_line_up.SetBinContent(ib, 0.0)
-                    h_line_down.SetBinContent(ib, 0.0)
-
-            # "data" histogram: copy of total, errors = sqrt(yield)
-            h_data = h_total.Clone(f"h_prefit_data_{era}")
-            h_data.SetDirectory(0)
-            for ib in range(1, n_bins+1):
-                y = h_data.GetBinContent(ib)
-                if y<0:
-                    y=0
-                h_data.SetBinError(ib, np.sqrt(y))
-            h_data.SetMarkerStyle(ROOT.kFullCircle)
-            h_data.SetMarkerSize(1.0)
-            h_data.SetLineColor(ROOT.kBlack)
-            h_data.SetFillStyle(0)
-            
-            nominal_histograms = [histogram_dict[era][sample][feature_name][first_uncertainty][0] for sample in samples_to_use]
-            nominal_histogram_integrals = [histogram.Integral() for histogram in nominal_histograms]
-
-            # adding plots to stack in ascending order of yields
-            yield_order = sorted(range(len(samples_to_use)), key=lambda i: nominal_histogram_integrals[i])
-            sample_labels_sorted = [samples_to_use[i] for i in yield_order]
-
-            stack_name = f"stack_prefit_{era}"
-            hs = ROOT.THStack(stack_name, "")
-            for i_sample, sample in enumerate(sample_labels_sorted):
-
-                h_nominal = histogram_dict[era][sample][feature_name][first_uncertainty][0]
-
-                sample_color = get_color(sample) if callable(get_color) else ROOT.kGray + 1
-
-                h_nominal.SetLineColor(ROOT.kBlack)
-                h_nominal.SetFillColor(sample_color)
-                h_nominal.SetLineWidth(1)
-
-                hs.Add(h_nominal, "hist")
-
-            canvas_name = f"c_prefit_{era}"
-            c_stack = ROOT.TCanvas(canvas_name, canvas_name, 800, 800)
-
-            padTop    = ROOT.TPad(canvas_name + "_top",    canvas_name + "_top",    0.0, 0.30, 1.0, 1.0)
-            padBottom = ROOT.TPad(canvas_name + "_bottom", canvas_name + "_bottom", 0.0, 0.00, 1.0, 0.30)
-
-            padTop.SetBottomMargin(0.0)
-            padTop.SetTopMargin(0.08)
-            padTop.SetLeftMargin(0.10)
-            padTop.SetRightMargin(0.05)
-            padTop.SetTicks(1, 1)
-
-            padBottom.SetTopMargin(0.0)
-            padBottom.SetBottomMargin(0.30)
-            padBottom.SetLeftMargin(0.10)
-            padBottom.SetRightMargin(0.05)
-            padBottom.SetTicks(1, 1)
-
-            padTop.Draw()
-            padBottom.Draw()
-
-            # ---- TOP PAD: absolute yields ----
-            padTop.cd()
-            if logY:
-                padTop.SetLogy(True)
-
-            hs.Draw("HIST")
-            hs.GetXaxis().SetTitle(x_title)
-            hs.GetYaxis().SetTitle("Events")
-
-            # font sizes / alignment (top pad)
-            hs.GetYaxis().SetTitleSize(0.05)     # a bit smaller
-            hs.GetYaxis().SetTitleOffset(1.1)    # helps align with bottom pad title
-            hs.GetYaxis().SetLabelSize(0.045)
-            hs.GetXaxis().SetLabelSize(0)
-            hs.GetXaxis().SetTitleSize(0)
-
-            # y-range
-            max_y = max(hs.GetMaximum(), h_data.GetMaximum())
-            if logY:
-                hs.SetMinimum(0.5)
-                hs.SetMaximum(10.0 * max_y if max_y > 0 else 1.0)
-            else:
-                hs.SetMinimum(0.0)
-                hs.SetMaximum(1.5 * max_y if max_y > 0 else 1.0)
-
-            # draw uncertainty band, lines, and data
-            for box in uncertainty_boxes:
-                box.Draw("SAME")
-            h_data.Draw("E SAME")
-
-            # legend
-            leg = ROOT.TLegend(0.50, 0.60, 0.88, 0.88)
-            leg.SetBorderSize(0)
-            leg.SetFillStyle(0)
-            leg.SetNColumns(legend_columns_prefit_stacks)
-
-            leg.AddEntry(h_data, "Data (Asimov)", "lep")
-            for sample in sample_labels_sorted:
-                h_nominal = histogram_dict[era][sample][feature_name][first_uncertainty][0]
-                leg.AddEntry(h_nominal, sample, "f")
-                logging.debug(f"{sample=}")
-            leg.AddEntry(uncertainty_boxes[0], "Uncertainty", "f")
-            leg.Draw()
-
-            # ---- BOTTOM PAD: ratios ----
-            padBottom.cd()
-
-            # ratio central
-            h_ratio_central = h_total.Clone(f"h_prefit_ratio_{era}")
-            h_ratio_central.SetDirectory(0)
-            h_ratio_central.Divide(h_total)  # becomes 1 where non-zero
-            h_ratio_central.SetLineColor(ROOT.kBlack)
-            h_ratio_central.SetLineWidth(2)
-            h_ratio_central.SetTitle("")
-
-            h_ratio_central.GetYaxis().SetTitle("var / nominal")
-            h_ratio_central.GetYaxis().SetNdivisions(505)
-            h_ratio_central.GetYaxis().SetTitleSize(0.09)
-            h_ratio_central.GetYaxis().SetTitleOffset(0.5)
-            h_ratio_central.GetYaxis().SetLabelSize(0.08)
-
-            h_ratio_central.GetXaxis().SetTitle(x_title)
-            h_ratio_central.GetXaxis().SetTitleSize(0.10)
-            h_ratio_central.GetXaxis().SetLabelSize(0.08)
-
-            # ratio uncertainty band via TBoxes + line-only histos
-            ratio_boxes = []
-
-            h_ratio_line_up   = h_ratio_central.Clone(f"h_prefit_ratio_up_{era}")
-            h_ratio_line_down = h_ratio_central.Clone(f"h_prefit_ratio_down_{era}")
-            h_ratio_line_up.SetDirectory(0)
-            h_ratio_line_down.SetDirectory(0)
-
-            # lines only, no fill
-            h_ratio_line_up.SetFillStyle(0)
-            h_ratio_line_up.SetFillColor(0)
-            h_ratio_line_down.SetFillStyle(0)
-            h_ratio_line_down.SetFillColor(0)
-            h_ratio_line_up.SetLineColor(ROOT.kGray + 2)
-            h_ratio_line_down.SetLineColor(ROOT.kGray + 2)
-            h_ratio_line_up.SetLineWidth(1)
-            h_ratio_line_down.SetLineWidth(1)
-
-            for ib in range(1, n_bins+1):
-                x1 = edges[ib-1]
-                x2 = edges[ib]
-                nom = h_total.GetBinContent(ib)
-                err_up = np.sqrt(h_unc_up.GetBinContent(ib))
-                err_down = np.sqrt(h_unc_down.GetBinContent(ib))   
-
-                if nom > 0.0:
-                    rel_up = err_up / nom
-                    rel_down = err_down / nom
-                    
-                    y_low  = 1.0 - rel_down
-                    y_high = 1.0 + rel_up
-
-                    box = ROOT.TBox(x1, y_low, x2, y_high)
-                    box.SetFillColor(ROOT.kGray + 1)
-                    box.SetFillStyle(3345)
-                    box.SetLineWidth(0)
-                    ratio_boxes.append(box)
-
-                    h_ratio_line_up.SetBinContent(ib, y_high)
-                    h_ratio_line_down.SetBinContent(ib, y_low)
-                else:
-                    # no prediction in this bin -> keep lines at 1
-                    h_ratio_line_up.SetBinContent(ib, 1.0)
-                    h_ratio_line_down.SetBinContent(ib, 1.0)
-
-            # ratio y-range from max relative deviation
-            max_dev = 0.0
-            for ib in range(1, n_bins+1):
-                nom = h_total.GetBinContent(ib)
-
-                err_up = np.sqrt(h_unc_up.GetBinContent(ib))
-                err_down = np.sqrt(h_unc_down.GetBinContent(ib))
-
-                if nom > 0:
-                    dev_up = err_up / nom
-                    dev_down = err_down / nom
-                    if max(dev_up,dev_down) > max_dev:
-                        max_dev = max(dev_up,dev_down)
-
-            if max_dev <= 0.0:
-                r_min, r_max = 0.9, 1.1
-            else:
-                half_range = 1.3 * max_dev
-                r_min = 1.0 - half_range
-                r_max = 1.0 + half_range
-
-            h_ratio_central.SetMinimum(max(r_min,-2.0))
-            h_ratio_central.SetMaximum(min(r_max,2.0))
-
-            # draw ratio
-            h_ratio_central.Draw("HIST")
-            for box in ratio_boxes:
-                box.Draw("SAME")
-            h_ratio_line_up.Draw("HIST SAME")
-            h_ratio_line_down.Draw("HIST SAME")
-
-            # line at 1
-            line = ROOT.TLine(edges[0], 1.0, edges[-1], 1.0)
-            line.SetLineStyle(ROOT.kDashed)
-            line.SetLineColor(ROOT.kBlack)
-            line.Draw("SAME")
-
-            c_stack.cd()
-            c_stack.Update()
-
-            helpers.copyIndexPHP(plot_directory_stacks)
-            out_png = os.path.join(plot_directory_stacks, f"{era}_{feature_name}_prefit.png")
-            out_pdf = os.path.join(plot_directory_stacks, f"{era}_{feature_name}_prefit.pdf")
-            c_stack.SaveAs(out_png)
-            c_stack.SaveAs(out_pdf)        
-
-
-    syncer.sync()
diff --git a/user/robert/prefit_sys_binned.py b/plot/prefitsys/prefit_sys_binned.py
similarity index 100%
rename from user/robert/prefit_sys_binned.py
rename to plot/prefitsys/prefit_sys_binned.py
diff --git a/user/robert/prefit_sys_binned.sh b/plot/prefitsys/prefit_sys_binned.sh
similarity index 100%
rename from user/robert/prefit_sys_binned.sh
rename to plot/prefitsys/prefit_sys_binned.sh
diff --git a/user/robert/variations.py b/plot/prefitsys/variations.py
similarity index 100%
rename from user/robert/variations.py
rename to plot/prefitsys/variations.py

From 4bfc0e25b8af09770044261507f17623bf65adbc Mon Sep 17 00:00:00 2001
From: Ricardo Barrue <ricardo.barrue@cern.ch>
Date: Thu, 23 Apr 2026 18:03:15 +0200
Subject: [PATCH 17/17] Postfit plot from unbinned config

---
 plot/postfitsys/unbinned_fromfit.py | 726 ++++++++++++++++++++++++++++
 1 file changed, 726 insertions(+)
 create mode 100644 plot/postfitsys/unbinned_fromfit.py

diff --git a/plot/postfitsys/unbinned_fromfit.py b/plot/postfitsys/unbinned_fromfit.py
new file mode 100644
index 0000000..ee9f0d2
--- /dev/null
+++ b/plot/postfitsys/unbinned_fromfit.py
@@ -0,0 +1,726 @@
+#!/usr/bin/env python3
+"""Postfit plots for unbinned fits using default feature binnings."""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import json
+import logging
+import os
+import sys
+from array import array
+from typing import Any
+
+import numpy as np
+import ROOT
+from tqdm import tqdm
+
+sys.path.insert(0, "..")
+sys.path.insert(0, "../..")
+
+import common.helpers as helpers
+import common.syncer as syncer
+import common.user as user
+import common.yaml_loader as yaml_loader
+
+from common.yaml_loader import _resolve_features_list
+from data.colors import get_color
+from data.plot_options import plot_options
+from fit.Likelihood import build_hypothesis_from_likelihood, expand_pois_linear_quadratic, load_likelihood, nuis_to_A_vector
+from fit.Modeling import Rotated
+
+ROOT.gROOT.SetBatch(True)
+ROOT.gStyle.SetOptStat(0)
+ROOT.TH1.AddDirectory(False)
+
+logging.basicConfig(level=logging.INFO, format="[%(levelname)s] %(message)s")
+logger = logging.getLogger(__name__)
+
+_KEEPALIVE = []
+
+
+def _safe_name(text: object) -> str:
+    """Return a ROOT-safe object name."""
+    return "".join(ch if (ch.isalnum() or ch == "_") else "_" for ch in str(text))
+
+
+def _hist_with_flow(values: np.ndarray, weights: np.ndarray, edges: np.ndarray) -> np.ndarray:
+    """Histogram values with under/overflow merged into first/last bins."""
+    n_bins = len(edges) - 1
+    idx = np.searchsorted(edges, values, side="right") - 1
+    out = np.bincount(idx[(idx >= 0) & (idx < n_bins)], weights=weights[(idx >= 0) & (idx < n_bins)], minlength=n_bins).astype(np.float64)
+
+    under = idx < 0
+    if np.any(under):
+        out[0] += np.sum(weights[under])
+    over = idx >= n_bins
+    if np.any(over):
+        out[-1] += np.sum(weights[over])
+    return out
+
+
+def build_class_shard_cache(
+    cls: dict[str, Any],
+    event_features: np.ndarray,
+    nominal_weights: np.ndarray,
+    feature_to_index: dict[str, int],
+) -> dict[str, Any]:
+    """Build per-shard surrogate cache so later evaluations are fast dot products."""
+    poi = cls.get("POI", {}) or {}
+    poi_params = list(poi.get("parameters", []) or [])
+    poi_predictor = poi.get("predictor", None)
+
+    n_events = event_features.shape[0]
+    if poi_predictor is None:
+        r_a = np.empty((n_events, 0), dtype=np.float64)
+    else:
+        poi_feature_names = list(getattr(poi_predictor, "feature_names", []) or [])
+        if poi_feature_names:
+            missing = [name for name in poi_feature_names if name not in feature_to_index]
+            if missing:
+                raise RuntimeError(
+                    f"Missing POI predictor features for class {cls.get('id', '?')}: {missing}"
+                )
+            poi_cols = [feature_to_index[name] for name in poi_feature_names]
+            events_for_poi = event_features[:, poi_cols]
+        else:
+            events_for_poi = event_features
+
+        r_a = np.asarray(poi_predictor.predict(events_for_poi), dtype=np.float64)
+        if r_a.ndim == 1:
+            r_a = r_a[:, None]
+
+    syst_caches = []
+    lnN_terms = []
+    for syst in cls.get("systematics", []) or []:
+        syst_type = syst.get("type")
+
+        if syst_type in ("pnn", "icp", "icph"):
+            syst_predictor = syst.get("predictor", None)
+            if syst_predictor is None:
+                raise RuntimeError(
+                    f"Missing {syst_type} predictor for {cls.get('id', '?')}/{syst.get('id', '?')}"
+                )
+
+            syst_feature_names = list(getattr(syst_predictor, "feature_names", []) or [])
+            if syst_feature_names:
+                missing = [name for name in syst_feature_names if name not in feature_to_index]
+                if missing:
+                    raise RuntimeError(
+                        f"Missing {syst_type} predictor features in {cls.get('id', '?')}/{syst.get('id', '?')}: {missing}"
+                    )
+                syst_cols = [feature_to_index[name] for name in syst_feature_names]
+                events_for_syst = event_features[:, syst_cols]
+            else:
+                events_for_syst = event_features
+
+            if hasattr(syst_predictor, "deltaA"):
+                delta_a = np.asarray(syst_predictor.deltaA(events_for_syst), dtype=np.float64)
+            else:
+                delta_a = np.asarray(syst_predictor.predict(events_for_syst), dtype=np.float64)
+            if delta_a.ndim == 1:
+                delta_a = delta_a[:, None]
+
+            syst_caches.append(
+                {
+                    "id": syst.get("id", "?"),
+                    "type": syst_type,
+                    "delta_a": delta_a,
+                    "params": list(syst.get("parameters", []) or []),
+                    "combinations": [tuple(item) for item in (syst.get("combinations", []) or [])],
+                }
+            )
+
+        elif syst_type == "lnN":
+            syst_params = list(syst.get("parameters", []) or [])
+            if len(syst_params) != 1:
+                raise RuntimeError(f"Bad lnN systematic definition: {syst}")
+            alpha = float(syst.get("value", 0.0))
+            lnN_terms.append((syst_params[0], float(np.log1p(alpha))))
+
+    return {
+        "features": np.asarray(event_features, dtype=np.float64),
+        "weights": np.asarray(nominal_weights, dtype=np.float64),
+        "poi_params": poi_params,
+        "r_a": r_a,
+        "syst_caches": syst_caches,
+        "lnN_terms": lnN_terms,
+    }
+
+
+def evaluate_class_cached(shard_cache: dict[str, Any], h_base: Any) -> np.ndarray:
+    """Evaluate event weights from cached surrogate tensors for a parameter point."""
+    event_weights = shard_cache["weights"]
+    n_events = len(event_weights)
+
+    poi_params = shard_cache["poi_params"]
+    r_a = shard_cache["r_a"]
+    if r_a.shape[1] > 0:
+        poi_values = {name: float(h_base[name].val) for name in poi_params}
+        c_a = expand_pois_linear_quadratic(poi_params, poi_values)
+        if r_a.shape[1] != len(c_a):
+            raise RuntimeError(
+                f"POI basis mismatch: predictor columns {r_a.shape[1]} != c_A length {len(c_a)}"
+            )
+        c_dot_r = r_a @ c_a
+    else:
+        c_dot_r = np.zeros(n_events, dtype=np.float64)
+
+    expo = np.zeros(n_events, dtype=np.float64)
+    for syst_cache in shard_cache["syst_caches"]:
+        params = syst_cache["params"]
+        combinations = syst_cache["combinations"]
+        nu_values = {name: float(h_base[name].val) for name in params}
+        nu_a = nuis_to_A_vector(params, combinations, nu_values)
+        delta_a = syst_cache["delta_a"]
+        if delta_a.shape[1] != len(nu_a):
+            raise RuntimeError(
+                f"{syst_cache['type']} basis mismatch in {syst_cache['id']}: "
+                f"predictor columns {delta_a.shape[1]} != nu_A length {len(nu_a)}"
+            )
+        expo += delta_a @ nu_a
+
+    for param_name, log1p_alpha in shard_cache["lnN_terms"]:
+        expo += float(log1p_alpha * float(h_base[param_name].val))
+
+    response = (1.0 + c_dot_r) * np.exp(expo)
+    return event_weights * response
+
+if __name__ == "__main__":
+    p = argparse.ArgumentParser(description="Simple postfit unbinned template plots from an external fit result")
+    p.add_argument("fit_result", help="Fit JSON file")
+    p.add_argument("--config", default=None, help="Config YAML. If omitted, try to read it from the fit JSON.")
+    p.add_argument("--rotate", default=None, help="Rotation JSON, same logic as Likelihood.py")
+    p.add_argument("--outdir", default=None, help="Output directory")
+    p.add_argument("--n-toys", default=1000, type=int, help="Number of covariance toys")
+    p.add_argument("--seed", default=42, type=int, help="Random seed")
+    p.add_argument("--min_ratio", type=float, help="Minimum of ratio pad.")
+    p.add_argument("--max_ratio", type=float, help="Maximum of ratio pad.")
+    args = p.parse_args()
+
+    fit: Any = json.load(open(args.fit_result))
+
+    config_path = args.config
+    if config_path is None:
+        config_path = fit.get("args", {}).get("config", None) or fit.get("config", None)
+    if config_path is None:
+        raise RuntimeError("Need --config, because no config path was found inside the fit JSON.")
+
+    logger.info("fit_result : %s", args.fit_result)
+    logger.info("config     : %s", config_path)
+    logger.info("rotate     : %s", args.rotate)
+
+    cfg: Any = yaml_loader.load_yaml(config_path)
+    yaml_loader.print_summary(cfg, config_path, yaml_loader._INCLUDE_TRACE)
+    yaml_loader.load_surrogates(cfg, config_path, overwrite=False)
+
+    like_info: Any = load_likelihood(cfg)
+    hyp = build_hypothesis_from_likelihood(like_info, name="SR")
+
+    if not like_info.get("regions", []):
+        raise RuntimeError("Config does not define unbinned regions in likelihood.regions")
+
+    default_feature_tokens = cfg.get("defaults", {}).get("default_features", []) or []
+    default_features = _resolve_features_list(default_feature_tokens)
+    plot_features = [feature for feature in default_features if feature in plot_options and "binning" in plot_options[feature]]
+    if not plot_features:
+        raise RuntimeError("No default feature has plot_options binning. Nothing to plot.")
+    feature_to_index = {name: i for i, name in enumerate(default_features)}
+
+    samples_mod = importlib.import_module(cfg["defaults"]["module_samples"])
+    factory = samples_mod.Factory(
+        features=default_features,
+        selection=cfg["defaults"].get("default_selection", None),
+        selection_features=cfg["defaults"].get("default_selection_features", None),
+    )
+
+    is_data_fit = "data" in args.fit_result
+    rotated = bool(args.rotate)
+    hyp_for_fit = Rotated(hyp, args.rotate, name="Fisher-basis") if rotated else hyp
+
+    fit_names = list(fit["free_parameter_order"])
+    fit_param_map = {p_item["name"]: float(p_item["value"]) for p_item in fit["parameters"]}
+    fit_cov = np.asarray(fit["covariance"]["matrix"], dtype=np.float64)
+
+    all_unfrozen = [par for par in hyp_for_fit.parameters if not par.isFrozen]
+    all_unfrozen_names = [par.name for par in all_unfrozen]
+    poi_name_set = {par.name for par in hyp_for_fit.POIs}
+
+    missing_in_fit = [n for n in all_unfrozen_names if n not in fit_param_map or n not in fit_names]
+    missing_pois_in_fit = [n for n in missing_in_fit if n in poi_name_set]
+    missing_other_in_fit = [n for n in missing_in_fit if n not in poi_name_set]
+
+    if missing_pois_in_fit:
+        logger.warning("These POIs are missing in fit JSON; setting to zero and not sampling: %s", missing_pois_in_fit)
+        for n in missing_pois_in_fit:
+            if hasattr(hyp_for_fit, n):
+                getattr(hyp_for_fit, n).val = 0.0
+            if hasattr(hyp, n):
+                getattr(hyp, n).val = 0.0
+
+    if missing_other_in_fit:
+        raise RuntimeError(f"These active non-POI parameters are missing in fit JSON: {missing_other_in_fit}")
+
+    extra_in_fit = [n for n in fit_names if n not in all_unfrozen_names]
+    if extra_in_fit:
+        logger.warning("Ignoring parameters present in fit JSON but not active here: %s", extra_in_fit)
+
+    active_params = [par for par in all_unfrozen if par.name in fit_param_map and par.name in fit_names]
+    active_names = [par.name for par in active_params]
+
+    fit_index = {name: idx for idx, name in enumerate(fit_names)}
+    cov_index = [fit_index[name] for name in active_names]
+    cov_active = fit_cov[np.ix_(cov_index, cov_index)]
+    mean_active = np.asarray([fit_param_map[name] for name in active_names], dtype=np.float64)
+
+    best_fit_hyp = hyp_for_fit.cloneModify(**{name: fit_param_map[name] for name in active_names})
+    best_base_hyp = best_fit_hyp._base
+
+    np.random.seed(args.seed)
+    if len(active_names) > 0 and args.n_toys > 0:
+        theta_samples = np.random.multivariate_normal(mean_active, cov_active, size=args.n_toys)
+    else:
+        theta_samples = np.zeros((0, len(active_names)), dtype=np.float64)
+
+    base = os.path.splitext(os.path.basename(config_path))[0]
+    base_fit_result = os.path.splitext(os.path.basename(args.fit_result))[0]
+    version = str(cfg.get("version", "v0"))
+    suffix = "_rotate" if rotated else ""
+    if args.outdir is None:
+        outdir = os.path.join(user.plot_directory, "unbinned_postfit_fromfit", base, f"{version}{suffix}", f"from_{base_fit_result}")
+    else:
+        outdir = args.outdir
+    os.makedirs(outdir, exist_ok=True)
+    helpers.copyIndexPHP(outdir)
+
+    logger.info("output dir : %s", outdir)
+    logger.info("n_toys     : %d", args.n_toys)
+
+    region_canvases: dict[str, ROOT.TCanvas] = {}
+
+    for region in like_info.get("regions", []) or []:
+        region_id = region["id"]
+        logger.info("plotting region %s", region_id)
+
+        class_infos = []
+        for cls in region.get("classes", []) or []:
+            class_id = cls["id"]
+            sample_name = cls.get("sample", class_id)
+            loader = factory.get(sample_name)
+            color = get_color(sample_name) if callable(get_color) else ROOT.kGray + 1
+
+            class_infos.append(
+                {
+                    "id": class_id,
+                    "sample": sample_name,
+                    "cls": cls,
+                    "loader": loader,
+                    "color": color,
+                }
+            )
+
+        if not class_infos:
+            logger.warning("Region %s has no classes, skipping.", region_id)
+            continue
+
+        if (not is_data_fit) and ("data" in region):
+            logger.warning(
+                "data sample in region %s, but fit result from MC-only fit. Plotting data as total MC.",
+                region_id,
+            )
+
+        if is_data_fit and "data" in region:
+            data_loader = factory.get(region["data"]["sample"])
+        else:
+            data_loader = None
+            if is_data_fit:
+                raise RuntimeError(f"Fit output looks like data fit, but region '{region_id}' has no data sample")
+
+        if is_data_fit:
+            assert data_loader is not None
+            data_shards_f = []
+            for shard_index in range(len(data_loader)):
+                (shard_features,) = data_loader.materialize(shard=shard_index, what="f", feature_names=default_features)
+                shard_features = np.asarray(shard_features, dtype=np.float64)
+                if shard_features.size == 0:
+                    continue
+                data_shards_f.append(shard_features)
+        else:
+            data_shards_f = []
+
+        for class_info in tqdm(class_infos, desc=f"[{region_id}] materialize classes", leave=False):
+            loader = class_info["loader"]
+            shards_fw = []
+            shard_caches = []
+            for shard_index in range(len(loader)):
+                shard_features, shard_weights = loader.materialize(shard=shard_index, what="fw", feature_names=default_features)
+                shard_features = np.asarray(shard_features, dtype=np.float64)
+                shard_weights = np.asarray(shard_weights, dtype=np.float64)
+                if shard_features.size == 0:
+                    continue
+                shards_fw.append((shard_features, shard_weights))
+                shard_caches.append(
+                    build_class_shard_cache(
+                        class_info["cls"],
+                        shard_features,
+                        shard_weights,
+                        feature_to_index,
+                    )
+                )
+            class_info["shards_fw"] = shards_fw
+            class_info["shard_caches"] = shard_caches
+
+        for feature_name in plot_features:
+            feature_index = feature_to_index[feature_name]
+            if feature_name not in plot_options:
+                raise RuntimeError(f"Feature '{feature_name}' is missing in data.plot_options")
+            if "binning" not in plot_options[feature_name]:
+                raise RuntimeError(f"Feature '{feature_name}' has no 'binning' entry in data.plot_options")
+            binning = plot_options[feature_name]["binning"]
+            if isinstance(binning, (list, tuple)) and len(binning) == 3 and isinstance(binning[0], int):
+                n_bins_cfg, x_low, x_high = binning
+                edges = np.linspace(float(x_low), float(x_high), int(n_bins_cfg) + 1, dtype=np.float64)
+            else:
+                edges = np.asarray(list(binning), dtype=np.float64)
+            x_title = plot_options.get(feature_name, {}).get("tex", feature_name)
+            log_y = bool(plot_options.get(feature_name, {}).get("logY", False))
+            n_bins = len(edges) - 1
+
+            logger.info(f"{feature_name=}")
+            total_central = np.zeros(n_bins, dtype=np.float64)
+            class_central_hists = []
+            class_labels = []
+
+            logging.info("evaluating nominal prediction")
+            for class_info in class_infos:
+                class_hist = np.zeros(n_bins, dtype=np.float64)
+
+                for shard_cache in class_info["shard_caches"]:
+                    event_weights = evaluate_class_cached(shard_cache, best_base_hyp)
+                    shard_features = shard_cache["features"]
+                    class_hist += _hist_with_flow(shard_features[:, feature_index], event_weights, edges)
+
+                total_central += class_hist
+                class_central_hists.append(class_hist)
+                class_labels.append(class_info["sample"])
+
+            logging.info(f"building histograms for sampled toy points, {len(theta_samples)=}")
+            if len(theta_samples) > 0:
+                total_samples = np.zeros((len(theta_samples), n_bins), dtype=np.float64)
+
+                for itoy, theta in enumerate(
+                    tqdm(theta_samples, desc=f"[{region_id}/{feature_name}] toys", leave=False)
+                ):
+                    toy_pars = {name: float(theta[i]) for i, name in enumerate(active_names)}
+                    toy_hyp = hyp_for_fit.cloneModify(**toy_pars)
+                    toy_base = toy_hyp._base
+
+                    toy_total = np.zeros(n_bins, dtype=np.float64)
+                    for class_info in class_infos:
+                        class_hist_toy = np.zeros(n_bins, dtype=np.float64)
+
+                        for shard_cache in class_info["shard_caches"]:
+                            event_weights_toy = evaluate_class_cached(shard_cache, toy_base)
+                            shard_features = shard_cache["features"]
+                            class_hist_toy += _hist_with_flow(shard_features[:, feature_index], event_weights_toy, edges)
+
+                        toy_total += class_hist_toy
+
+                    total_samples[itoy, :] = toy_total
+
+                q_low = np.quantile(total_samples, 0.16, axis=0)
+                q_high = np.quantile(total_samples, 0.84, axis=0)
+            else:
+                q_low = total_central.copy()
+                q_high = total_central.copy()
+
+            class_hists = []
+            for class_info, values in zip(class_infos, class_central_hists):
+                h_cls = ROOT.TH1F(
+                    f"h_postfit_{_safe_name(region_id)}_{_safe_name(feature_name)}_{_safe_name(class_info['id'])}",
+                    "",
+                    len(edges) - 1,
+                    array("d", edges),
+                )
+                h_cls.SetDirectory(0)
+                for ibin, value in enumerate(values, start=1):
+                    h_cls.SetBinContent(ibin, float(value))
+                h_cls.SetLineColor(ROOT.kBlack)
+                h_cls.SetFillColor(class_info["color"])
+                h_cls.SetLineWidth(1)
+                class_hists.append(h_cls)
+
+            h_total = ROOT.TH1F(
+                f"h_postfit_total_{_safe_name(region_id)}_{_safe_name(feature_name)}",
+                "",
+                len(edges) - 1,
+                array("d", edges),
+            )
+            h_total.SetDirectory(0)
+            for ibin, value in enumerate(total_central, start=1):
+                h_total.SetBinContent(ibin, float(value))
+
+            h_unc = h_total.Clone(f"h_postfit_unc_{_safe_name(region_id)}_{_safe_name(feature_name)}")
+            h_unc.SetDirectory(0)
+            for ibin, (nominal, low, high) in enumerate(zip(total_central, q_low, q_high), start=1):
+                err = max(abs(nominal - low), abs(high - nominal))
+                h_unc.SetBinError(ibin, float(err))
+            h_unc.SetFillColor(ROOT.kGray + 1)
+            h_unc.SetFillStyle(3345)
+            h_unc.SetLineWidth(0)
+            h_unc.SetMarkerSize(0)
+
+            h_unc_up = h_total.Clone(f"h_postfit_unc_up_{_safe_name(region_id)}_{_safe_name(feature_name)}")
+            h_unc_down = h_total.Clone(f"h_postfit_unc_down_{_safe_name(region_id)}_{_safe_name(feature_name)}")
+            h_unc_up.SetDirectory(0)
+            h_unc_down.SetDirectory(0)
+            for ibin in range(1, n_bins + 1):
+                nominal = h_total.GetBinContent(ibin)
+                err = h_unc.GetBinError(ibin)
+                h_unc_up.SetBinContent(ibin, nominal + err)
+                h_unc_down.SetBinContent(ibin, max(0.0, nominal - err))
+                h_unc_up.SetBinError(ibin, 0.0)
+                h_unc_down.SetBinError(ibin, 0.0)
+            h_unc_up.SetLineColor(ROOT.kGray + 2)
+            h_unc_down.SetLineColor(ROOT.kGray + 2)
+            h_unc_up.SetLineWidth(1)
+            h_unc_down.SetLineWidth(1)
+            h_unc_up.SetFillStyle(0)
+            h_unc_down.SetFillStyle(0)
+
+            h_data = h_total.Clone(f"h_postfit_data_{_safe_name(region_id)}_{_safe_name(feature_name)}")
+            h_data.SetDirectory(0)
+            if is_data_fit:
+                for ibin in range(1, n_bins + 1):
+                    h_data.SetBinContent(ibin, 0.0)
+                for shard_features in data_shards_f:
+                    unit_weights = np.ones(shard_features.shape[0], dtype=np.float64)
+                    data_counts = _hist_with_flow(shard_features[:, feature_index], unit_weights, edges)
+                    for ibin, value in enumerate(data_counts, start=1):
+                        h_data.SetBinContent(ibin, h_data.GetBinContent(ibin) + float(value))
+            for ibin in range(1, n_bins + 1):
+                y_val = h_data.GetBinContent(ibin)
+                h_data.SetBinError(ibin, np.sqrt(max(0.0, y_val)))
+            h_data.SetMarkerStyle(ROOT.kFullCircle)
+            h_data.SetMarkerSize(1.0)
+            h_data.SetLineColor(ROOT.kBlack)
+            h_data.SetFillStyle(0)
+
+            h_ratio_data = h_data.Clone(f"h_postfit_ratio_data_{_safe_name(region_id)}_{_safe_name(feature_name)}")
+            h_ratio_data.SetDirectory(0)
+
+            max_dev_data = 0.0
+            for ibin in range(1, n_bins + 1):
+                nominal = h_total.GetBinContent(ibin)
+                y_val = h_data.GetBinContent(ibin)
+                y_err = h_data.GetBinError(ibin)
+                if nominal > 0.0:
+                    rel = max(abs(y_val + y_err - nominal), abs(y_val - y_err - nominal)) / nominal
+                    h_ratio_data.SetBinContent(ibin, y_val / nominal)
+                    h_ratio_data.SetBinError(ibin, y_err / nominal)
+                    max_dev_data = max(max_dev_data, rel)
+                else:
+                    h_ratio_data.SetBinContent(ibin, 0.0)
+                    h_ratio_data.SetBinError(ibin, 0.0)
+
+            h_ratio_data.SetMarkerStyle(ROOT.kFullCircle)
+            h_ratio_data.SetMarkerSize(1.0)
+            h_ratio_data.SetLineColor(ROOT.kBlack)
+            h_ratio_data.SetMarkerColor(ROOT.kBlack)
+            h_ratio_data.SetLineWidth(1)
+            h_ratio_data.SetFillStyle(0)
+
+            integrals = [h.Integral(1, n_bins) for h in class_hists]
+            order = sorted(range(len(class_hists)), key=lambda idx: integrals[idx])
+            class_hists_sorted = [class_hists[idx] for idx in order]
+            class_labels_sorted = [class_labels[idx] for idx in order]
+
+            hs = ROOT.THStack(f"stack_postfit_{_safe_name(region_id)}_{_safe_name(feature_name)}", "")
+            for h_cls in class_hists_sorted:
+                hs.Add(h_cls, "hist")
+
+            canvas_name = f"c_postfit_{_safe_name(region_id)}_{_safe_name(feature_name)}"
+            c = ROOT.TCanvas(canvas_name, canvas_name, 900, 900)
+            pad_top = ROOT.TPad(c.GetName() + "_top", c.GetName() + "_top", 0.0, 0.30, 1.0, 1.0)
+            pad_bottom = ROOT.TPad(c.GetName() + "_bottom", c.GetName() + "_bottom", 0.0, 0.00, 1.0, 0.30)
+
+            pad_top.SetBottomMargin(0.0)
+            pad_top.SetTopMargin(0.08)
+            pad_top.SetLeftMargin(0.10)
+            pad_top.SetRightMargin(0.05)
+            pad_top.SetTicks(1, 1)
+
+            pad_bottom.SetTopMargin(0.0)
+            pad_bottom.SetBottomMargin(0.30)
+            pad_bottom.SetLeftMargin(0.10)
+            pad_bottom.SetRightMargin(0.05)
+            pad_bottom.SetTicks(1, 1)
+
+            pad_top.Draw()
+            pad_bottom.Draw()
+
+            pad_top.cd()
+            if log_y:
+                pad_top.SetLogy(True)
+
+            hs.Draw("HIST")
+            hs.GetYaxis().SetTitle("Events")
+            hs.GetYaxis().SetTitleSize(0.05)
+            hs.GetYaxis().SetTitleOffset(1.1)
+            hs.GetYaxis().SetLabelSize(0.045)
+            hs.GetXaxis().SetLabelSize(0)
+            hs.GetXaxis().SetTitleSize(0)
+
+            max_y = max(hs.GetMaximum(), h_data.GetMaximum())
+            if log_y:
+                hs.SetMinimum(0.5)
+                hs.SetMaximum(10.0 * max_y if max_y > 0 else 1.0)
+            else:
+                hs.SetMinimum(0.0)
+                hs.SetMaximum(1.5 * max_y if max_y > 0 else 1.0)
+
+            h_unc.Draw("E2 SAME")
+            h_unc_up.Draw("HIST SAME")
+            h_unc_down.Draw("HIST SAME")
+            h_data.Draw("E SAME")
+
+            leg = ROOT.TLegend(0.50, 0.60, 0.88, 0.88)
+            leg.SetBorderSize(0)
+            leg.SetFillStyle(0)
+            leg.SetNColumns(2)
+            if is_data_fit:
+                leg.AddEntry(h_data, "Data", "lep")
+            else:
+                leg.AddEntry(h_data, "Data (Asimov)", "lep")
+            for h_cls, label_text in zip(class_hists_sorted, class_labels_sorted):
+                leg.AddEntry(h_cls, label_text, "f")
+            leg.AddEntry(h_unc, "Uncertainty", "f")
+            leg.Draw()
+
+            title = ROOT.TLatex()
+            title.SetNDC(True)
+            title.SetTextSize(0.035)
+            title.DrawLatex(0.12, 0.93, f"{region_id} - {feature_name}")
+
+            pad_bottom.cd()
+
+            h_ratio = h_total.Clone(f"h_postfit_ratio_{_safe_name(region_id)}_{_safe_name(feature_name)}")
+            h_ratio.SetDirectory(0)
+            h_ratio.Divide(h_total)
+            h_ratio.SetLineColor(ROOT.kBlack)
+            h_ratio.SetLineWidth(2)
+            h_ratio.SetTitle("")
+            h_ratio.GetYaxis().SetTitle("data / MC" if is_data_fit else "var / nominal")
+            h_ratio.GetYaxis().SetNdivisions(505)
+            h_ratio.GetYaxis().SetTitleSize(0.09)
+            h_ratio.GetYaxis().SetTitleOffset(0.5)
+            h_ratio.GetYaxis().SetLabelSize(0.08)
+            h_ratio.GetXaxis().SetTitle(x_title)
+            h_ratio.GetXaxis().SetTitleSize(0.10)
+            h_ratio.GetXaxis().SetLabelSize(0.08)
+
+            ratio_boxes = []
+            h_ratio_up = h_ratio.Clone(f"h_postfit_ratio_up_{_safe_name(region_id)}_{_safe_name(feature_name)}")
+            h_ratio_down = h_ratio.Clone(f"h_postfit_ratio_down_{_safe_name(region_id)}_{_safe_name(feature_name)}")
+            h_ratio_up.SetDirectory(0)
+            h_ratio_down.SetDirectory(0)
+            h_ratio_up.SetFillStyle(0)
+            h_ratio_down.SetFillStyle(0)
+            h_ratio_up.SetLineColor(ROOT.kGray + 2)
+            h_ratio_down.SetLineColor(ROOT.kGray + 2)
+            h_ratio_up.SetLineWidth(1)
+            h_ratio_down.SetLineWidth(1)
+
+            max_dev = 0.0
+            for ibin in range(1, n_bins + 1):
+                x1 = float(edges[ibin - 1])
+                x2 = float(edges[ibin])
+                nominal = h_total.GetBinContent(ibin)
+                err = h_unc.GetBinError(ibin)
+                if nominal > 0.0:
+                    rel = err / nominal
+                    y_low = 1.0 - rel
+                    y_high = 1.0 + rel
+
+                    box = ROOT.TBox(x1, y_low, x2, y_high)
+                    box.SetFillColor(ROOT.kGray + 1)
+                    box.SetFillStyle(3345)
+                    box.SetLineWidth(0)
+                    ratio_boxes.append(box)
+
+                    h_ratio_up.SetBinContent(ibin, y_high)
+                    h_ratio_down.SetBinContent(ibin, y_low)
+                    max_dev = max(max_dev, rel)
+                else:
+                    h_ratio_up.SetBinContent(ibin, 1.0)
+                    h_ratio_down.SetBinContent(ibin, 1.0)
+
+            if is_data_fit:
+                max_dev = max(max_dev, max_dev_data)
+
+            if max_dev <= 0.0:
+                r_min, r_max = 0.9, 1.1
+            else:
+                half_range = 1.3 * max_dev
+                r_min = 1.0 - half_range
+                r_max = 1.0 + half_range
+
+            if args.min_ratio:
+                h_ratio.SetMinimum(args.min_ratio)
+            else:
+                h_ratio.SetMinimum(r_min)
+
+            if args.max_ratio:
+                h_ratio.SetMaximum(args.max_ratio)
+            else:
+                h_ratio.SetMaximum(r_max)
+                
+            h_ratio.Draw("HIST")
+            for box in ratio_boxes:
+                box.Draw("SAME")
+            h_ratio_up.Draw("HIST SAME")
+            h_ratio_down.Draw("HIST SAME")
+            h_ratio_data.Draw("E1 X0 SAME")
+
+            unity = ROOT.TLine(float(edges[0]), 1.0, float(edges[-1]), 1.0)
+            unity.SetLineStyle(ROOT.kDashed)
+            unity.SetLineColor(ROOT.kBlack)
+            unity.Draw("SAME")
+
+            c.cd()
+            c.Update()
+
+            out_png = os.path.join(outdir, f"{_safe_name(region_id)}__{_safe_name(feature_name)}__postfit.png")
+            out_pdf = os.path.join(outdir, f"{_safe_name(region_id)}__{_safe_name(feature_name)}__postfit.pdf")
+            c.SaveAs(out_png)
+            c.SaveAs(out_pdf)
+            logger.info("wrote %s", out_png)
+            logger.info("wrote %s", out_pdf)
+
+            region_canvases[f"{region_id}::{feature_name}"] = c
+            _KEEPALIVE.extend(
+                [
+                    c,
+                    pad_top,
+                    pad_bottom,
+                    hs,
+                    h_total,
+                    h_unc,
+                    h_unc_up,
+                    h_unc_down,
+                    h_data,
+                    h_ratio,
+                    h_ratio_data,
+                    h_ratio_up,
+                    h_ratio_down,
+                    leg,
+                    title,
+                    unity,
+                ]
+                + class_hists_sorted
+                + ratio_boxes
+            )
+
+    logger.info("done, produced %d plots", len(region_canvases))
+    syncer.sync()