From 6dc71040a198d44d4f6863aae23b3f90d722f64f Mon Sep 17 00:00:00 2001
From: Jarred Roberts <jarredroberts24@gmail.com>
Date: Mon, 1 Jun 2026 18:15:00 -0700
Subject: [PATCH 1/2] Add StripEnergyThresholdFinder app

---
 apps/StripEnergyThresholdFinder.cxx         | 1892 +++++++++++++++++++
 apps/StripEnergyThresholdFinder_config.yaml |   18 +
 2 files changed, 1910 insertions(+)
 create mode 100644 apps/StripEnergyThresholdFinder.cxx
 create mode 100644 apps/StripEnergyThresholdFinder_config.yaml

diff --git a/apps/StripEnergyThresholdFinder.cxx b/apps/StripEnergyThresholdFinder.cxx
new file mode 100644
index 00000000..642715ac
--- /dev/null
+++ b/apps/StripEnergyThresholdFinder.cxx
@@ -0,0 +1,1892 @@
+/*
+ * StripEnergyThresholdFinder.cpp
+ *
+ * Author: Jarred Roberts
+ * Affiliation: UC San Diego, Department of Astronomy & Astrophysics
+ *
+ * Description:
+ *   Application for determining per-strip energy thresholds for germanium detectors.
+ *   Includes both slow (energy-based) and fast (timing-based) threshold estimation,
+ *   along with diagnostic outputs and ROOT-based visualization tools.
+ *
+ * Notes:
+ *   - Built on MEGAlib and Nuclearizer frameworks
+ *   - Uses ROOT for analysis and visualization
+ *
+ * Copyright (C) 2026 Jarred Roberts
+ *
+ * This software is provided for research and academic use.
+ * Redistribution and modification should follow the licensing
+ * terms of the parent frameworks (MEGAlib/Nuclearizer) where applicable.
+ */
+ 
+// NOTES:
+// Compile Command
+/* 
+
+h5c++ -O2 StripEnergyThresholdFinder.cxx -o StripEnergyThresholdFinder \
+$(root-config --cflags --libs) \
+-I$MEGALIB/include \
+-I~/COSItools/nuclearizer/include \
+-L$MEGALIB/lib \
+-lMEGAlib -lNuclearizer -lyaml-cpp
+
+*/
+
+#include <iostream>
+#include <fstream>
+#include <map>
+#include <vector>
+#include <cmath>
+#include <string>
+#include <sstream>
+
+#include <filesystem>
+namespace fs = std::filesystem;
+
+
+using namespace std;
+
+/* ROOT */
+#include <TROOT.h>
+#include <TFile.h>
+#include <TH1D.h>
+#include <TH2D.h>
+#include <TGraph.h>
+#include "TLegend.h"
+#include <TLine.h>
+#include <getopt.h>
+#include "TStyle.h"
+
+/* YAML */
+#include <yaml-cpp/yaml.h>
+
+/* MEGAlib */
+#include "MGlobal.h"
+#include "MSupervisor.h"
+#include "MModuleLoaderMeasurementsHDF.h"
+#include "MReadOutAssembly.h"
+#include "MStripHit.h"
+#include "MString.h"
+
+
+/* ------------------------------------------------------------- */
+/* Strip identifier structure                                     */
+/* ------------------------------------------------------------- */
+
+struct StripKey
+{
+  int det;
+  char side;
+  int strip;
+
+  bool operator<(const StripKey& o) const
+  {
+    if(det!=o.det) return det<o.det;
+    if(side!=o.side) return side<o.side;
+    return strip<o.strip;
+  }
+};
+
+
+/* -------------------------------------------------------------   */
+/* Simple calibration helper                                       */
+/* Converts ADC → Energy using polynomial calibration coefficients */
+/* -------------------------------------------------------------   */
+
+class EnergyCalHelper
+{
+public:
+
+  struct Coeff
+  {
+    double c0=0;
+    double c1=0;
+    double c2=0;
+    double c3=0;
+  };
+
+  bool Load(const string& fileName,int nDet=64,int nStrip=65)
+  {
+    m_NDet=nDet;
+    m_NStrip=nStrip;
+
+    m_Coeffs.resize(m_NDet);
+
+    for(int d=0;d<m_NDet;d++)
+    {
+      m_Coeffs[d].resize(2);
+
+      for(int s=0;s<2;s++)
+        m_Coeffs[d][s].resize(m_NStrip);
+    }
+
+    ifstream in(fileName);
+
+    if(!in)
+    {
+      cout<<"Unable to open calibration file "<<fileName<<endl;
+      return false;
+    }
+
+    string line;
+
+    while(getline(in,line))
+    {
+      if(line.empty()) continue;
+
+      stringstream ss(line);
+
+      string tag;
+      ss>>tag;
+
+      if(tag!="CM") continue;
+
+      string unused;
+      int det=-1;
+      int strip=-1;
+      string side;
+      string order;
+
+      ss>>unused>>det>>strip>>side>>order;
+
+      if(det<0||det>=m_NDet) continue;
+      if(strip<0||strip>=m_NStrip) continue;
+
+      int sideInt=(side=="l")?0:1;
+
+      Coeff c;
+
+      if(order=="poly1zero")
+        ss>>c.c1;
+      else if(order=="poly1")
+        ss>>c.c0>>c.c1;
+      else if(order=="poly2")
+        ss>>c.c0>>c.c1>>c.c2;
+      else
+        ss>>c.c0>>c.c1>>c.c2>>c.c3;
+
+      m_Coeffs[det][sideInt][strip]=c;
+    }
+
+    return true;
+  }
+
+  double ADCToEnergy(int det,char side,int strip,double adc) const
+  {
+    int sideInt=(side=='l')?0:1;
+    const Coeff& c=m_Coeffs[det][sideInt][strip];
+
+    return c.c3*pow(adc,3)+c.c2*pow(adc,2)+c.c1*adc+c.c0;
+  }
+
+private:
+
+  int m_NDet;
+  int m_NStrip;
+
+  vector<vector<vector<Coeff>>> m_Coeffs;
+};
+
+/* ------------------------------------------------------------- */
+/* TAC calibration helper                                        */
+/* ------------------------------------------------------------- */
+
+class TACCalHelper
+{
+public:
+
+  struct Coeff
+  {
+    double slope = 0;
+    double offset = 0;
+  };
+
+  bool Load(const string& fileName)
+  {
+    ifstream in(fileName);
+    if(!in)
+    {
+      cout<<"Failed to open TAC calibration file: "<<fileName<<endl;
+      return false;
+    }
+
+    string line;
+    getline(in,line); // skip header
+
+    while(getline(in,line))
+    {
+      if(line.empty()) continue;
+
+      stringstream ss(line);
+
+      int strip_id, det, side, strip;
+      double slope, slope_err, offset, offset_err;
+
+      ss >> strip_id >> det >> side >> strip
+         >> slope >> slope_err >> offset >> offset_err;
+
+      char sideChar = (side==0) ? 'l' : 'h';
+
+      StripKey key{det, sideChar, strip};
+
+      m_Coeffs[key] = {slope, offset};
+    }
+
+    return true;
+  }
+
+  double TACToEnergy(int det, char side, int strip, double tac) const
+  {
+    StripKey key{det, side, strip};
+
+    auto it = m_Coeffs.find(key);
+    if(it == m_Coeffs.end()) return 0;
+
+    return it->second.slope * tac + it->second.offset;
+  }
+
+private:
+  map<StripKey, Coeff> m_Coeffs;
+};
+
+
+/* ------------------------------------------------------------- */
+/* Hit selection                                                 */
+/* ------------------------------------------------------------- */
+
+bool PassHitSelection(MStripHit* SH)
+{
+  if(SH==nullptr) return false;
+
+  if(SH->IsGuardRing()) return true;
+  if(SH->IsNearestNeighbor()) return false;
+
+  return true;
+}
+
+
+
+
+int main(int argc,char** argv)
+{ 
+
+  // Force unbuffered stdout so progress bar updates live
+  setvbuf(stdout, NULL, _IONBF, 0);
+  
+  /* ------------------------------------------------------------- */
+  /* We Include this help menu so that users can define their      */
+  /* Variables,, without needing a yaml config file                */
+  /* ------------------------------------------------------------- */
+
+  for(int i=1;i<argc;i++)
+  {
+    string arg = argv[i];
+
+    if(arg == "--help" || arg == "-h")
+    {
+      cout<<endl;
+      cout<<"StripEnergyThresholdFinder"<<endl;
+      cout<<endl;
+      cout<<"Usage:"<<endl;
+      cout<<"  ./StripEnergyThresholdFinder config.yaml [options]"<<endl;
+      cout<<endl;
+      cout<<"Options:"<<endl;
+	  cout<<"Input/Output overrides:"<<endl;
+      cout<<"  --data_file FILE            Add data file (can be used multiple times)"<<endl;
+      cout<<"  --calibration_file FILE"<<endl;
+      cout<<"  --strip_map FILE"<<endl;
+      cout<<"  --output_prefix NAME"<<endl;
+      cout<<endl;
+      cout<<"  --min_entries N              Minimum entries required in strip histogram"<<endl;
+      cout<<"  --noise_search_max_adc N     Maximum ADC value used when locating noise peak"<<endl;
+      cout<<"  --fallback_threshold_keV N   Threshold assigned if algorithm fails"<<endl;
+      cout<<"  --help                       Show this help menu"<<endl;
+      cout<<endl;
+      cout<<"Example:"<<endl;
+      cout<<"  ./StripEnergyThresholdFinder config.yaml --noise_search_max_adc 1800"<<endl;
+      cout<<endl;
+      return 0;
+    }
+  }
+   
+  //TH1::AddDirectory(false);
+  MGlobal::Initialize("Standalone","ThresholdFinder");
+
+  if(argc<2)
+  {
+    cout<<"Usage: ./StripEnergyThresholdFinder config.yaml"<<endl;
+    return -1;
+  }
+
+  string configFile=argv[1];
+  YAML::Node config=YAML::LoadFile(configFile);
+
+  int minEntries=10;
+  double fallbackThreshold=20;
+  int histogramBins=2048;
+  double histogramMaxADC=4096;
+  double noise_search_max_adc=2200;
+  
+  /* ------------------------------------------------------------- */
+  /* Command line override parameters (optional)                   */
+  /* ------------------------------------------------------------- */
+
+  int cmd_min_entries = -1;
+  double cmd_noise_search_max_adc = -1;
+  double cmd_fallback_threshold_keV = -1;
+  
+  string cmd_data_file = "";
+  string cmd_calibration_file = "";
+  string cmd_strip_map = "";
+  string cmd_output_prefix = "";
+  long max_events = -1;
+
+  /* ------------------------------------------------------------- */
+  /* YAML file input loading                                       */
+  /* ------------------------------------------------------------- */
+
+  if(config["analysis"])
+  {
+    if(config["analysis"]["min_entries"])
+      minEntries=config["analysis"]["min_entries"].as<int>();
+
+    if(config["analysis"]["fallback_threshold_keV"])
+      fallbackThreshold=config["analysis"]["fallback_threshold_keV"].as<double>();
+
+    if(config["analysis"]["histogram_bins"])
+      histogramBins=config["analysis"]["histogram_bins"].as<int>();
+
+    if(config["analysis"]["histogram_max_adc"])
+      histogramMaxADC=config["analysis"]["histogram_max_adc"].as<double>();
+
+    if(config["analysis"]["noise_search_max_adc"])
+      noise_search_max_adc=config["analysis"]["noise_search_max_adc"].as<double>();
+  }
+
+
+  vector<string> inputFiles=config["input"]["data_files"].as<vector<string>>();
+  
+  if (inputFiles.empty()) {
+    cerr << "Error: No input files provided." << endl;
+    return 1;
+  }
+  
+  string calibrationFile=config["input"]["calibration_file"].as<string>();
+  string stripMapFileStr=config["input"]["strip_map"].as<string>();
+  string outfile=config["output"]["prefix"].as<string>();
+
+
+  EnergyCalHelper helperCal;
+  TACCalHelper helperCal_TAC;
+  
+  if(!helperCal.Load(calibrationFile))
+  {
+    cout<<"Failed to load calibration file: "<<calibrationFile<<endl;
+    return -1;
+  }
+  
+  string tacCalibrationFile = config["input"]["tac_calibration_file"].as<string>();
+
+  
+  
+  /* ------------------------------------------------------------- */
+  /* Modern command line parser using getopt_long                  */
+  /* ------------------------------------------------------------- */
+
+  static struct option long_options[] =
+  {
+    {"min_entries", required_argument, 0, 'm'},
+    {"noise_search_max_adc", required_argument, 0, 'n'},
+    {"fallback_threshold_keV", required_argument, 0, 'f'},
+
+    /* NEW overrides */
+    {"data_file", required_argument, 0, 'd'},
+    {"calibration_file", required_argument, 0, 'c'},
+    {"strip_map", required_argument, 0, 's'},
+    {"output_prefix", required_argument, 0, 'o'},
+	{"max_events", required_argument, 0, 'e'},
+
+    {"help", no_argument, 0, 'h'},
+    {0,0,0,0}
+  };
+
+  optind = 2;   // skip program name and YAML file
+
+  int opt;
+  while((opt = getopt_long(argc, argv, "", long_options, NULL)) != -1)
+  {
+    switch(opt)
+    {
+      case 'm':
+        cmd_min_entries = atoi(optarg);
+        break;
+
+      case 'n':
+        cmd_noise_search_max_adc = atof(optarg);
+        break;
+
+      case 'f':
+        cmd_fallback_threshold_keV = atof(optarg);
+        break;
+		
+	  //case 'd':
+        //cmd_data_file = optarg;
+        //break;
+      case 'd':
+        inputFiles.push_back(optarg);
+        break;
+		
+	  case 'e':
+        max_events = atol(optarg);
+        break; 
+		
+      case 'c':
+        cmd_calibration_file = optarg;
+        break;
+
+      case 's':
+        cmd_strip_map = optarg;
+        break;
+
+      case 'o':
+        cmd_output_prefix = optarg;
+        break;
+
+      case 'h':
+        cout<<endl;
+        cout<<"Usage:"<<endl;
+        cout<<"  ./StripEnergyThresholdFinder config.yaml [options]"<<endl;
+        cout<<endl;
+        cout<<"Options:"<<endl;
+		cout<<"Input/Output overrides:"<<endl;
+        cout<<"  --data_file FILE            Override YAML data file"<<endl;
+        cout<<"  --calibration_file FILE     Override calibration file"<<endl;
+        cout<<"  --strip_map FILE            Override strip map"<<endl;
+        cout<<"  --output_prefix NAME        Override output file prefix"<<endl;
+        cout<<endl;
+        cout<<"  --min_entries N              Minimum histogram entries"<<endl;
+        cout<<"  --noise_search_max_adc N     Max ADC for noise search"<<endl;
+        cout<<"  --fallback_threshold_keV N   Default threshold if fit fails"<<endl;
+        cout<<"  --help                       Show this message"<<endl;
+        cout<<endl;
+        exit(0);
+
+      default:
+        break;
+    }
+  }
+  
+  /* ------------------------------------------------------------- */
+  /* Apply command line overrides for input/output                  */
+  /* ------------------------------------------------------------- */
+
+
+  if(cmd_calibration_file != "")
+  {
+    calibrationFile = cmd_calibration_file;
+  }
+
+  if(cmd_strip_map != "")
+  {
+    stripMapFileStr = cmd_strip_map;
+  }
+
+  if(cmd_output_prefix != "")
+  {
+    outfile = cmd_output_prefix;
+  } 
+  
+  // Determine output directory from first data file
+  fs::path dataPath(inputFiles.back());
+  fs::path outputDir = dataPath.parent_path();
+
+  // Resolve outfile path
+  fs::path outPath(outfile);
+
+  if (!outPath.is_absolute())
+  {
+    outfile = (outputDir / outPath).string();
+  }
+  //outfile = fs::weakly_canonical(outfile).string();
+
+  // Debug print
+  cout << "Resolved output prefix: " << outfile << endl;
+  
+  MString stripMapFile = stripMapFileStr.c_str();
+
+  /* ------------------------------------------------------------- */
+  /* Apply command line overrides if provided                      */
+  /* ------------------------------------------------------------- */
+
+  if(cmd_min_entries >= 0)
+    minEntries = cmd_min_entries;
+
+  if(cmd_noise_search_max_adc > 0)
+    noise_search_max_adc = cmd_noise_search_max_adc;
+
+  if(cmd_fallback_threshold_keV > 0)
+    fallbackThreshold = cmd_fallback_threshold_keV;
+
+
+  MSupervisor* S=MSupervisor::GetSupervisor();
+
+  map<StripKey,TH1D*> histograms;
+  map<StripKey,TH1D*> histograms_TAC;
+  
+  map<StripKey, map<int, pair<int,int>>> timingCounts;
+  
+  /* ------------------------------------------------------------- */
+  /* Save configuration to log file                                */
+  /* ------------------------------------------------------------- */
+  
+  cout<<endl;
+  cout<<"  calibration_file:        "<<calibrationFile<<endl;
+  cout<<"  strip_map:               "<<stripMapFileStr<<endl;
+  cout<<"  output_prefix:           "<<outfile<<endl;
+
+  cout<<"  data_files:"<<endl;
+  for(auto &f : inputFiles)
+      cout<<"    "<<f<<endl;
+
+  cout<<endl;
+  cout<<"Active analysis configuration:"<<endl;
+  cout<<"  min_entries:            "<<minEntries<<endl;
+  cout<<"  fallback_threshold_keV: "<<fallbackThreshold<<endl;
+  cout<<"  noise_search_max_adc:   "<<noise_search_max_adc<<endl;
+  cout<<"  histogram_bins:         "<<histogramBins<<endl;
+  cout<<"  histogram_max_adc:      "<<histogramMaxADC<<endl;
+  cout<<endl;
+
+
+  /* ------------------------------------------------------------- */
+  /* Build ADC histograms from data                                */
+  /* ------------------------------------------------------------- */
+
+  for(string inputFile:inputFiles)
+  {
+
+    MModuleLoaderMeasurementsHDF* Loader=new MModuleLoaderMeasurementsHDF();
+    Loader->SetFileName(inputFile.c_str());
+    Loader->SetFileNameStripMap(stripMapFile);
+
+    S->SetModule(Loader,0);
+
+    if(!Loader->Initialize()) return -1;
+
+    MReadOutAssembly* Event=new MReadOutAssembly();
+    
+	long event_counter = 0;
+    while(Loader->IsFinished()==false)
+    {
+      if(max_events > 0 && event_counter >= max_events)
+        break;
+	  Event->Clear();
+
+      if(Loader->IsReady())
+      {
+        Loader->AnalyzeEvent(Event);
+		event_counter++;
+
+        for(unsigned int sh=0;sh<Event->GetNStripHits();sh++)
+        {
+          MStripHit* SH=Event->GetStripHit(sh);
+
+          if(!PassHitSelection(SH)) continue;
+
+          double adc=SH->GetADCUnits();
+		  
+		  int det=SH->GetDetectorID();
+          int strip=SH->GetStripID();
+          char side=SH->IsLowVoltageStrip()?'l':'h';
+		  
+		  StripKey key{det,side,strip};
+		  
+		  /* ------------------------------------------------------------- */
+          /* Fast threshold data accumulation (dt0 vs dt1)                 */
+          /* ------------------------------------------------------------- */
+
+          int adc_int = (int)adc;
+
+          // Define timing type
+          int timing_type = SH->HasFastTiming() ? 1 : 0;
+
+          // Accumulate counts
+          auto& entry = timingCounts[key][adc_int];
+
+          if(timing_type == 0)
+            entry.first++;
+          else
+            entry.second++;
+		  
+		  /* ------------------------------------------------------------- */
+          /* TAC (fast shaper) histogram filling                           */
+          /* ------------------------------------------------------------- */
+
+          if(SH->HasFastTiming() && SH->GetTAC() > 0)
+          {
+            double tac = SH->GetTAC();
+
+            //StripKey key{det,side,strip};
+
+            if(histograms_TAC[key]==nullptr)
+            {
+              string name="h_TAC_"+to_string(det)+"_"+side+"_"+to_string(strip);
+
+              histograms_TAC[key]=new TH1D(
+                name.c_str(),
+                name.c_str(),
+                histogramBins,0,histogramMaxADC);
+
+              histograms_TAC[key]->GetXaxis()->SetTitle("TAC ADC");
+              histograms_TAC[key]->GetYaxis()->SetTitle("Counts");
+            }
+
+            histograms_TAC[key]->Fill(tac);
+          }
+		  
+		  
+		  
+		  static int debugCounter = 0;
+
+          if(histograms[key]==nullptr)
+          {
+            string name="h_"+to_string(det)+"_"+side+"_"+to_string(strip);
+
+            histograms[key]=new TH1D(name.c_str(),name.c_str(),
+                                     histogramBins,0,histogramMaxADC);
+
+            histograms[key]->GetXaxis()->SetTitle("ADC");
+            histograms[key]->GetYaxis()->SetTitle("Counts");
+          }
+
+          histograms[key]->Fill(adc);
+        }
+      }
+    }
+
+    delete Event;
+  }
+
+
+  /* ------------------------------------------------------------- */
+  /* Threshold finding algorithm                                   */
+  /* ------------------------------------------------------------- */
+
+  map<StripKey,double> thresholds;
+  map<StripKey,double> thresholdsADC;
+  
+  // Progress tracking (slow thresholds)
+  int totalStrips = histograms.size();
+  int processedStrips = 0;
+
+  map<int,double> thresholdLV;
+  map<int,double> thresholdHV;
+
+  map<int,double> thresholdLV_ADC;
+  map<int,double> thresholdHV_ADC;
+  
+  /* ------------------------------------------------------------- */
+  /* Fast shaper (TAC) histograms                                  */
+  /* ------------------------------------------------------------- */
+
+  //map<StripKey,TH1D*> histograms_TAC;
+  
+  /* ------------------------------------------------------------- */
+  /* TAC threshold storage                                         */
+  /* ------------------------------------------------------------- */
+
+  map<StripKey,double> thresholds_TAC;
+  map<StripKey,double> thresholds_TAC_ADC;
+  //map<StripKey, map<int, pair<int,int>>> timingCounts;
+  
+  
+  /* HV/LV split */
+
+  map<int,double> thresholdLV_TAC;
+  map<int,double> thresholdHV_TAC;
+
+  map<int,double> thresholdLV_TAC_ADC;
+  map<int,double> thresholdHV_TAC_ADC;
+  
+  
+  
+  /* ------------------------------------------------------------- */
+  /* Diagnostic storage vectors                                     */
+  /* These vectors allow us to build ROOT diagnostic plots later    */
+  /* ------------------------------------------------------------- */
+
+  vector<double> stripIndex;
+  vector<double> thresholdValues;
+  vector<double> noisePeakADC;
+  
+  /* ------------------------------------------------------------- */
+  /* Separate vectors for HV and LV strip diagnostics               */
+  /* ------------------------------------------------------------- */
+
+  vector<double> stripIndex_LV;
+  vector<double> stripIndex_HV;
+
+  vector<double> thresholdValues_LV;
+  vector<double> thresholdValues_HV;
+
+  vector<double> noisePeakADC_LV;
+  vector<double> noisePeakADC_HV;
+  
+  /* ------------------------------------------------------------- */
+  /* TAC diagnostic vectors                                        */
+  /* ------------------------------------------------------------- */
+
+  vector<double> stripIndex_TAC_LV;
+  vector<double> stripIndex_TAC_HV;
+
+  vector<double> thresholdValues_TAC_LV;
+  vector<double> thresholdValues_TAC_HV;
+
+  vector<double> tacPeakADC_LV;
+  vector<double> tacPeakADC_HV;
+  
+  vector<double> slowEnergyVec;
+  vector<double> tacEnergyVec;
+
+  for(auto& kv:histograms)
+  {
+
+    StripKey key=kv.first;
+    TH1D* hist=kv.second;
+
+    if(hist->GetEntries()<minEntries)
+    {
+      thresholds[key]=fallbackThreshold;
+      continue;
+    }
+
+    hist->Smooth(3);
+
+    int maxSearchBin=hist->FindBin(noise_search_max_adc);
+
+    int startBin=-1;
+
+    for(int b=1;b<=maxSearchBin;b++)
+      if(hist->GetBinContent(b)>5){ startBin=b; break; }
+
+    if(startBin<0)
+    {
+      thresholds[key]=fallbackThreshold;
+      continue;
+    }
+
+    int peakBin=startBin;
+    double peakCounts=hist->GetBinContent(startBin);
+
+    for(int b=startBin+1;b<=maxSearchBin;b++)
+    {
+      double c=hist->GetBinContent(b);
+
+      if(c>peakCounts){ peakCounts=c; peakBin=b; }
+      else if(b>peakBin && c<peakCounts*0.9) break;
+    }
+
+    int thresholdBin=peakBin;
+
+    if(key.strip==64)
+    {
+      for(int b=peakBin+1;b<=maxSearchBin;b++)
+        if(hist->GetBinContent(b)<=peakCounts*0.5)
+        { thresholdBin=b; break; }
+    }
+    else
+    {
+      for(int b=peakBin+1;b<=maxSearchBin;b++)
+      {
+        double c=hist->GetBinContent(b);
+
+        if(c<hist->GetBinContent(thresholdBin))
+          thresholdBin=b;
+
+        if(b>peakBin && c>peakCounts*0.5)
+          break;
+      } 
+    }
+	
+
+    /* ------------------------------------------------------------- */
+    /* Shift threshold slightly to the right of the noise trough     */
+    /* This prevents thresholds from sitting inside the noise tail   */
+    /* ------------------------------------------------------------- */
+
+    int shiftBins = 2;   // move threshold up by a couple of bins
+    thresholdBin = min(thresholdBin + shiftBins, hist->GetNbinsX());
+
+    double thresholdADC = hist->GetBinCenter(thresholdBin);
+
+    /* Convert ADC → keV using SLOW calibration */
+    double thresholdKeV =
+      helperCal.ADCToEnergy(key.det,key.side,key.strip,thresholdADC);
+
+    /* Store SLOW thresholds */
+    thresholds[key] = thresholdKeV;
+    thresholdsADC[key] = thresholdADC;
+	
+	// Progress bar update
+    processedStrips++;
+
+    int barWidth = 40;
+    float progress = (float)processedStrips / totalStrips;
+
+    cout << "\r[";
+    int pos = barWidth * progress;
+
+    for(int i = 0; i < barWidth; ++i)
+    {
+      if(i < pos) cout << "=";
+      else if(i == pos) cout << ">";
+      else cout << " ";
+    }
+
+    cout << "] " << int(progress * 100.0) << "%" << flush;
+
+    /* ------------------------------------------------------------- */
+    /* Store values for diagnostic plots                             */
+    /* ------------------------------------------------------------- */
+
+    stripIndex.push_back(key.strip);
+    thresholdValues.push_back(thresholdKeV);
+    noisePeakADC.push_back(hist->GetBinCenter(peakBin));
+	
+	/* -------------------------------------------------------------- */
+    /* Store HV and LV diagnostics separately so both appear in plots */
+    /* -------------------------------------------------------------- */
+
+    if(key.side=='l')
+    {
+        stripIndex_LV.push_back(key.strip);
+        thresholdValues_LV.push_back(thresholdKeV);
+        noisePeakADC_LV.push_back(hist->GetBinCenter(peakBin));
+    }
+    else
+    {
+        stripIndex_HV.push_back(key.strip);
+        thresholdValues_HV.push_back(thresholdKeV);
+        noisePeakADC_HV.push_back(hist->GetBinCenter(peakBin));
+    }
+
+    if(key.side=='l')
+    {
+	  thresholdLV[key.strip]=thresholdKeV;
+      thresholdLV_ADC[key.strip]=thresholdADC;
+    }
+    else
+    {
+      thresholdHV[key.strip]=thresholdKeV;
+      thresholdHV_ADC[key.strip]=thresholdADC;
+    }
+	
+  }
+  cout << endl;
+  
+  /* ------------------------------------------------------------- */
+  /* Fast threshold finder (dt0 vs dt1 crossover)                  */
+  /* ------------------------------------------------------------- */
+
+  for(auto& kv : timingCounts)
+  {
+    StripKey key = kv.first;
+    auto& adcMap = kv.second;
+
+    // --- FIX: skip guard ring for FAST thresholds ---
+    if(key.strip == 64)
+    {
+      continue;
+    }
+	
+	int totalCounts = 0;
+    for(auto& a : adcMap)
+      totalCounts += a.second.first + a.second.second;
+
+    //if(totalCounts < minEntries)
+		
+	// Proper minEntries guard
+    if(totalCounts < minEntries)
+    {
+      thresholds_TAC[key] = fallbackThreshold;
+      continue;
+    }
+
+    // Find first nonzero ADC
+    int first_nonzero = -1;
+
+    for(auto& a : adcMap)
+    {
+      if(a.second.first + a.second.second > 0)
+      {
+        first_nonzero = a.first + 10;
+        break;
+      }
+    }
+
+    if(first_nonzero < 0)
+    {
+      thresholds_TAC[key] = fallbackThreshold;
+      continue;
+    }
+	
+	
+    //cout << "FAST threshold RMS  (keV): " << hFastThreshDist->GetRMS() << endl;
+
+    int bestADC = -1;
+    int minDiff = 1e9;
+	
+	// -------------------------------------------------------------
+    // Direct crossover detection (no smoothing bias)
+    // -------------------------------------------------------------
+    int crossoverADC = -1;
+
+    for(auto& a : adcMap)
+    {
+      int adc_val = a.first;
+      int n0 = a.second.first;
+      int n1 = a.second.second;
+
+      // Require minimum statistics to avoid noise triggers
+      if(n0 + n1 < 10) continue;
+
+      if(n1 > n0)
+      {
+        crossoverADC = adc_val;
+        break;
+      }
+    }
+
+    int nbins = 21;
+
+    // Extend search window for stability
+    int searchMax = first_nonzero + 800;
+
+    for(int adc = first_nonzero; adc < searchMax; adc++)
+    {
+      int n_dt0 = 0;
+      int n_dt1 = 0;
+
+      for(int a = adc; a < adc + nbins; a++)
+      {
+        if(adcMap.find(a) == adcMap.end()) continue;
+
+        n_dt0 += adcMap[a].first;
+        n_dt1 += adcMap[a].second;
+      }
+
+      int diff;
+
+      if(n_dt0 == 0 && n_dt1 == 0)
+        diff = 1000000;
+      else
+        diff = abs(n_dt1 - n_dt0);
+
+      if(diff < minDiff)
+      {
+        minDiff = diff;
+        bestADC = adc;
+      }
+    }
+
+    if(bestADC < 0)
+    {
+      thresholds_TAC[key] = fallbackThreshold;
+      continue;
+    }
+
+
+    // prefer physical crossover if available
+    int fast_thresh_adc;
+
+    if(crossoverADC > 0)
+    {
+      fast_thresh_adc = crossoverADC;
+    }
+    else
+    {
+      // fallback to old method
+      fast_thresh_adc = bestADC + nbins/2;
+    }
+	
+	/*cout << "[FAST DEBUG] strip " << key.strip
+         << " bestADC=" << bestADC
+         << " crossoverADC=" << crossoverADC
+         << endl;*/
+
+    thresholds_TAC_ADC[key] = fast_thresh_adc;
+
+    double fast_thresh_keV =
+      helperCal.ADCToEnergy(key.det,key.side,key.strip,fast_thresh_adc);
+
+    thresholds_TAC[key] = fast_thresh_keV;
+
+    /* Store diagnostics */
+
+    if(key.side=='l')
+    {
+      stripIndex_TAC_LV.push_back(key.strip);
+      thresholdValues_TAC_LV.push_back(fast_thresh_keV);
+    }
+    else
+    {
+      stripIndex_TAC_HV.push_back(key.strip);
+      thresholdValues_TAC_HV.push_back(fast_thresh_keV);
+    }
+
+    /* Debug print */
+
+    /*cout << "[FAST] DET " << key.det
+         << " " << key.side
+         << " strip " << key.strip
+         << " ADC: " << fast_thresh_adc
+         << " keV: " << fast_thresh_keV
+         << endl;*/
+    
+  } 
+
+
+  
+  /* ------------------------------------------------------------- */
+  /* Write CSV threshold tables (HV and LV)                        */
+  /* ------------------------------------------------------------- */
+
+  ofstream csv_HV(outfile + "_Slow_HV_thresholds.csv");
+  ofstream csv_LV(outfile + "_Slow_LV_thresholds.csv");
+
+  /* CSV headers */
+
+  csv_HV << "detector_side,strip,threshold_adc,threshold_keV\n";
+  csv_LV << "detector_side,strip,threshold_adc,threshold_keV\n";
+
+  /* Write rows */
+
+  for(const auto& kv : thresholds)
+  {
+    char side = kv.first.side;
+    int strip = kv.first.strip;
+
+    double thr_keV = kv.second;	
+	double thr_adc = thresholdsADC[kv.first];
+    	
+	
+	if(side == 'h')
+    {
+      csv_HV << "h,"
+             << strip << ","
+             << thr_adc << ","
+             << thr_keV << "\n";
+    }
+    else if(side == 'l')
+    {
+      csv_LV << "l,"
+             << strip << ","
+             << thr_adc << ","
+             << thr_keV << "\n";
+    }
+  }
+  
+  
+  /* ------------------------------------------------------------- */
+  /* Pixel threshold maps                                          */
+  /* ------------------------------------------------------------- */
+
+  TH2D pixelThresholdMap(
+    "PixelThresholdMap",
+    "Pixel Threshold Map (keV);LV Strip;HV Strip",
+    64,0,64,
+    64,64,0);
+
+  TH2D pixelThresholdADCMap(
+    "PixelThresholdADCMap",
+    "Pixel Threshold Map (ADC);LV Strip;HV Strip",
+    64,0,64,
+    64,64,0);
+
+  /* force ROOT to display full strip axes */
+
+  pixelThresholdMap.GetXaxis()->SetNdivisions(64,false);
+  pixelThresholdMap.GetYaxis()->SetNdivisions(64,false);
+
+  pixelThresholdADCMap.GetXaxis()->SetNdivisions(64,false);
+  pixelThresholdADCMap.GetYaxis()->SetNdivisions(64,false);
+
+
+  for(int lv=0;lv<64;lv++)
+  {
+    if(thresholdLV.find(lv)==thresholdLV.end()) continue;
+
+    for(int hv=0;hv<64;hv++)
+    {
+      if(thresholdHV.find(hv)==thresholdHV.end()) continue;
+
+      double pixelThr=max(thresholdLV[lv],thresholdHV[hv]);
+      pixelThresholdMap.Fill(lv,hv,pixelThr);
+
+      double pixelADC=max(thresholdLV_ADC[lv],thresholdHV_ADC[hv]);
+      pixelThresholdADCMap.Fill(lv,hv,pixelADC);
+    }
+  }
+
+  
+  /* ------------------------------------------------------------- */
+  /* Write CSV threshold tables (SLOW + FAST)                      */
+  /* ------------------------------------------------------------- */
+
+  // --- FAST CSV ---
+  ofstream csv_TAC_HV(outfile + "_Fast_HV_thresholds.csv");
+  ofstream csv_TAC_LV(outfile + "_Fast_LV_thresholds.csv");
+
+  csv_TAC_HV << "detector_side,strip,threshold_adc,threshold_keV\n";
+  csv_TAC_LV << "detector_side,strip,threshold_adc,threshold_keV\n";
+
+  cout << "Writing FAST CSV entries: " << thresholds_TAC.size() << endl;
+  
+  for(const auto& kv : thresholds_TAC)
+  {
+    char side = kv.first.side;
+    int strip = kv.first.strip;
+
+    double thr_adc = thresholds_TAC_ADC[kv.first];
+    double thr_keV = kv.second;
+
+    if(side == 'h')
+    {
+      csv_TAC_HV << "h," << strip << "," << thr_adc << "," << thr_keV << "\n";
+    }
+    else if(side == 'l')
+    {
+      csv_TAC_LV << "l," << strip << "," << thr_adc << "," << thr_keV << "\n";
+    }
+  }
+
+  csv_TAC_HV.close();
+  csv_TAC_LV.close();
+  
+  
+  
+  /* ------------------------------------------------------------- */
+  /* ROOT output                                                   */
+  /* ------------------------------------------------------------- */
+  //cout << "DEBUG: outfile being used = " << outfile << endl;
+  TFile f((outfile+"_diagnostics.root").c_str(),"RECREATE");
+  
+
+
+  /* ------------------------------------------------------------- */
+  /*  Slow and Fast Threshold diagnostic plots                     */
+  /* ------------------------------------------------------------- */
+ 
+
+  // -------------------------------------------------------------
+  // SLOW threshold per strip (HV vs LV scatter)
+  // -------------------------------------------------------------
+  TGraph* gSlowThresh_LV = new TGraph();
+  TGraph* gSlowThresh_HV = new TGraph();
+
+  gSlowThresh_LV->SetName("SlowThresh_LV");
+  gSlowThresh_HV->SetName("SlowThresh_HV");
+
+  // Axis titles
+  gSlowThresh_LV->SetTitle("Slow Threshold per Strip;Strip;Threshold (keV)");
+
+  // Styling
+  gSlowThresh_LV->SetMarkerStyle(20);   // circle
+  gSlowThresh_LV->SetMarkerSize(1.0);
+  gSlowThresh_LV->SetMarkerColor(kBlue);
+
+  gSlowThresh_HV->SetMarkerStyle(20);   
+  gSlowThresh_HV->SetMarkerSize(1.0);
+  gSlowThresh_HV->SetMarkerColor(kRed);
+
+  // Fill graphs
+  for(const auto& kv : thresholds)
+  {
+    int strip = kv.first.strip;
+    char side = kv.first.side;
+    double thr = kv.second;
+
+
+    if(side == 'l')
+      gSlowThresh_LV->SetPoint(gSlowThresh_LV->GetN(), strip, thr);
+
+    if(side == 'h')
+      gSlowThresh_HV->SetPoint(gSlowThresh_HV->GetN(), strip, thr);
+  }
+
+  // -------------------------------------------------------------
+  // Canvas with legend
+  // -------------------------------------------------------------
+  TCanvas* cSlowThresh = new TCanvas("cSlowThresh","Slow Threshold per Strip",800,600);
+  cSlowThresh->cd();
+
+  // Draw LV first (sets axes)
+  gSlowThresh_LV->Draw("AP");
+
+  // Optional: auto-scale Y axis
+  double ymin = 1e9, ymax = -1e9;
+  for(const auto& kv : thresholds)
+  {
+    if(kv.first.strip == 64) continue;
+    double v = kv.second;
+    if(v < ymin) ymin = v;
+    if(v > ymax) ymax = v;
+  }
+  double pad = 0.1 * (ymax - ymin);
+  gSlowThresh_LV->GetYaxis()->SetRangeUser(ymin - pad, ymax + pad);
+
+  // Overlay HV
+  gSlowThresh_HV->Draw("P SAME");
+
+  // Legend
+  TLegend* legSlowScatter = new TLegend(0.7,0.72,0.8,0.8);
+  legSlowScatter->AddEntry(gSlowThresh_LV, "LV", "p");
+  legSlowScatter->AddEntry(gSlowThresh_HV, "HV", "p");
+
+  legSlowScatter->SetTextSize(0.02);
+  legSlowScatter->SetBorderSize(1);
+  legSlowScatter->SetFillStyle(0);
+
+  legSlowScatter->Draw();
+
+  // Finalize
+  cSlowThresh->Modified();
+  cSlowThresh->Update();
+
+  // Save
+  cSlowThresh->Write();
+  gSlowThresh_LV->Write();
+  gSlowThresh_HV->Write();
+ 
+  // -------------------------------------------------------------
+  // SLOW threshold distribution (HV vs LV separated)
+  // -------------------------------------------------------------
+  TH1D* hSlowDist_LV = new TH1D(
+    "SlowThresholdDistribution_LV",
+    "Slow Threshold Distribution;Threshold (keV);Counts",
+    100, 0, 50
+  );
+
+  TH1D* hSlowDist_HV = new TH1D(
+    "SlowThresholdDistribution_HV",
+    "Slow Threshold Distribution;Threshold (keV);Counts",
+    100, 0, 50
+  );
+
+  // Styling
+  hSlowDist_LV->SetLineColor(kBlue);
+  hSlowDist_LV->SetLineWidth(2);
+
+  hSlowDist_HV->SetLineColor(kRed);
+  hSlowDist_HV->SetLineWidth(2);
+
+  // Fill histograms
+  for(const auto& kv : thresholds)
+  {
+    int strip = kv.first.strip;
+    char side = kv.first.side;
+    double thr = kv.second;
+
+    if(strip == 64) continue;
+
+    if(side == 'l') hSlowDist_LV->Fill(thr);
+    if(side == 'h') hSlowDist_HV->Fill(thr);
+  }
+
+  // -------------------------------------------------------------
+  // Canvas with legend
+  // -------------------------------------------------------------
+  TCanvas* cSlowDist = new TCanvas("cSlowDist","Slow Threshold Distribution",800,600);
+  cSlowDist->cd();
+
+  // Draw LV first
+  hSlowDist_LV->Draw("HIST");
+
+  // Overlay HV
+  hSlowDist_HV->Draw("HIST SAME");
+
+  // Legend
+  TLegend* legSlow = new TLegend(0.7,0.72,0.8,0.8);
+  legSlow->AddEntry(hSlowDist_LV, "LV", "l");
+  legSlow->AddEntry(hSlowDist_HV, "HV", "l");
+  legSlow->Draw();
+
+  // Finalize
+  cSlowDist->Modified();
+  cSlowDist->Update();
+
+  // Write everything
+  cSlowDist->Write();
+  hSlowDist_LV->Write();
+  hSlowDist_HV->Write();
+  
+  
+
+
+  // -------------------------------------------------------------
+  // FAST threshold per strip histogram
+  // -------------------------------------------------------------
+  TH1D* hFastThreshPerStrip = new TH1D(
+    "FastThresholds_per_strip",
+    "Fast Threshold per Strip;Strip;Threshold (keV)",
+    65, 0, 65
+  );
+
+  for(const auto& kv : thresholds_TAC)
+  {
+    int strip = kv.first.strip;
+    double thr_keV = kv.second;
+
+    if(strip == 64) continue;   // skip guard ring
+
+    hFastThreshPerStrip->SetBinContent(strip + 1, thr_keV);
+  }
+
+  hFastThreshPerStrip->Write();
+
+
+  
+  
+  /* ------------------------------------------------------------- */
+  /* Threshold vs strip for HV and LV sides                        */
+  /* ------------------------------------------------------------- */
+
+  TGraph Threshold_vs_Strip_LV(
+    stripIndex_LV.size(),
+    stripIndex_LV.data(),
+    thresholdValues_LV.data());
+
+  Threshold_vs_Strip_LV.SetName("Threshold_vs_Strip_LV");
+  Threshold_vs_Strip_LV.SetTitle("Threshold vs Strip;Strip;Threshold (keV)");
+
+  Threshold_vs_Strip_LV.SetMarkerStyle(20);
+  Threshold_vs_Strip_LV.SetMarkerColor(kBlue);
+  Threshold_vs_Strip_LV.SetMarkerSize(1);
+
+  Threshold_vs_Strip_LV.Write();
+
+
+  TGraph Threshold_vs_Strip_HV(
+    stripIndex_HV.size(),
+    stripIndex_HV.data(),
+    thresholdValues_HV.data());
+
+  Threshold_vs_Strip_HV.SetName("Threshold_vs_Strip_HV");
+
+  Threshold_vs_Strip_HV.SetMarkerStyle(20);
+  Threshold_vs_Strip_HV.SetMarkerColor(kRed);
+  Threshold_vs_Strip_HV.SetMarkerSize(1);
+
+  Threshold_vs_Strip_HV.Write();
+
+
+
+  /* ------------------------------------------------------------- */
+  /* Noise peak ADC vs strip for HV and LV sides                   */
+  /* ------------------------------------------------------------- */
+
+  TGraph NoisePeakADC_vs_Strip_LV(
+    stripIndex_LV.size(),
+    stripIndex_LV.data(),
+    noisePeakADC_LV.data());
+
+  NoisePeakADC_vs_Strip_LV.SetName("NoisePeakADC_vs_Strip_LV");
+  NoisePeakADC_vs_Strip_LV.SetTitle("Noise Peak ADC vs Strip;Strip;Noise Peak (ADC)");
+
+  NoisePeakADC_vs_Strip_LV.SetMarkerStyle(20);
+  NoisePeakADC_vs_Strip_LV.SetMarkerColor(kBlue);
+  NoisePeakADC_vs_Strip_LV.SetMarkerSize(1);
+
+  NoisePeakADC_vs_Strip_LV.Write();
+
+
+  TGraph NoisePeakADC_vs_Strip_HV(
+    stripIndex_HV.size(),
+    stripIndex_HV.data(),
+    noisePeakADC_HV.data());
+
+  NoisePeakADC_vs_Strip_HV.SetName("NoisePeakADC_vs_Strip_HV");
+
+  NoisePeakADC_vs_Strip_HV.SetMarkerStyle(20);
+  NoisePeakADC_vs_Strip_HV.SetMarkerColor(kRed);
+  NoisePeakADC_vs_Strip_HV.SetMarkerSize(1);
+
+  NoisePeakADC_vs_Strip_HV.Write();
+
+ 
+
+  
+  /* ------------------------------------------------------------- */
+  /* TAC Threshold vs Strip                                        */
+  /* ------------------------------------------------------------- */
+
+  TGraph Threshold_TAC_vs_Strip_LV(
+    stripIndex_TAC_LV.size(),
+    stripIndex_TAC_LV.data(),
+    thresholdValues_TAC_LV.data());
+
+  Threshold_TAC_vs_Strip_LV.SetName("Threshold_TAC_vs_Strip_LV");
+  Threshold_TAC_vs_Strip_LV.SetTitle("TAC Threshold vs Strip;Strip;Threshold (keV)");
+  Threshold_TAC_vs_Strip_LV.SetMarkerStyle(20);
+  Threshold_TAC_vs_Strip_LV.SetMarkerColor(kBlue);
+  Threshold_TAC_vs_Strip_LV.SetMarkerSize(1);
+
+  Threshold_TAC_vs_Strip_LV.Write();
+
+
+  TGraph Threshold_TAC_vs_Strip_HV(
+    stripIndex_TAC_HV.size(),
+    stripIndex_TAC_HV.data(),
+    thresholdValues_TAC_HV.data());
+
+  Threshold_TAC_vs_Strip_HV.SetName("Threshold_TAC_vs_Strip_HV");
+  Threshold_TAC_vs_Strip_HV.SetMarkerStyle(20);
+  Threshold_TAC_vs_Strip_HV.SetMarkerColor(kRed);
+  Threshold_TAC_vs_Strip_HV.SetMarkerSize(1);
+
+  Threshold_TAC_vs_Strip_HV.Write();
+  
+  
+  
+  
+  
+  /* ------------------------------------------------------------- */
+  /* Write ADC spectra and create energy spectra with thresholds   */
+  /* ------------------------------------------------------------- */
+
+  for(auto& kv:histograms)
+  {
+    StripKey key=kv.first;
+    TH1D* adcHist=kv.second;
+
+    adcHist->Write();
+
+    string name="Energy_"+to_string(key.det)+"_"+key.side+"_"+to_string(key.strip);
+
+    TH1D* energyHist=new TH1D(
+        name.c_str(),
+        name.c_str(),
+        adcHist->GetNbinsX(),
+        0,
+        helperCal.ADCToEnergy(key.det,key.side,key.strip,histogramMaxADC)
+    );
+
+    for(int b=1;b<=adcHist->GetNbinsX();b++)
+    {
+      double adc=adcHist->GetBinCenter(b);
+      double energy=helperCal.ADCToEnergy(key.det,key.side,key.strip,adc);
+      double counts=adcHist->GetBinContent(b);
+
+      int ebin=energyHist->FindBin(energy);
+      energyHist->AddBinContent(ebin,counts);
+    }
+
+    double thr=thresholds[key];
+
+    TLine* line=new TLine(thr,0,thr,energyHist->GetMaximum());
+    line->SetLineColor(kRed);
+    line->SetLineWidth(2);
+
+    energyHist->GetListOfFunctions()->Add(line);
+
+    energyHist->Write();
+  }
+  
+
+  // -------------------------------------------------------------
+  // FAST threshold distribution (HV vs LV separated)
+  // -------------------------------------------------------------
+  TH1D* hFastDist_LV = new TH1D(
+    "FastThresholdDistribution_LV",
+    "Fast Threshold Distribution;Threshold (keV);Counts",
+    100, 0, 100
+  );
+
+  TH1D* hFastDist_HV = new TH1D(
+    "FastThresholdDistribution_HV",
+    "Fast Threshold Distribution;Threshold (keV);Counts",
+    100, 0, 100
+  );
+
+  // Styling
+  hFastDist_LV->SetLineColor(kBlue);
+  hFastDist_LV->SetLineWidth(2);
+
+  hFastDist_HV->SetLineColor(kRed);
+  hFastDist_HV->SetLineWidth(2);
+
+  // Fill histograms
+  for(const auto& kv : thresholds_TAC)
+  {
+    int strip = kv.first.strip;
+    char side = kv.first.side;
+    double thr = kv.second;
+
+    if(strip == 64) continue;
+
+    if(side == 'l') hFastDist_LV->Fill(thr);
+    if(side == 'h') hFastDist_HV->Fill(thr);
+  }
+
+  // -------------------------------------------------------------
+  // Canvas with legend
+  // -------------------------------------------------------------
+  TCanvas* cFastDist = new TCanvas("cFastDist","Fast Threshold Distribution",800,600);
+  cFastDist->cd();
+
+  // Draw LV first
+  hFastDist_LV->Draw("HIST");
+ 
+  // Overlay HV
+  hFastDist_HV->Draw("HIST SAME");
+
+  // Legend
+  TLegend* leg2 = new TLegend(0.70,0.72,0.8,0.8);
+  leg2->AddEntry(hFastDist_LV, "LV", "l");
+  leg2->AddEntry(hFastDist_HV, "HV", "l");
+  leg2->Draw();
+
+  // Finalize
+  cFastDist->Modified();
+  cFastDist->Update();
+
+  // Write everything
+  cFastDist->Write();
+  hFastDist_LV->Write();
+  hFastDist_HV->Write();
+  
+  
+
+  // Distribution in ADC
+  TH1D* FastThresholdDistribution_ADC = new TH1D(
+    "FastThresholdDistribution_ADC",
+    "Fast Threshold Distribution (ADC);ADC;Counts",
+    200, 0, 2000
+  );
+
+  for(const auto& kv : thresholds_TAC_ADC)
+  {
+    FastThresholdDistribution_ADC->Fill(kv.second);
+  }
+
+  FastThresholdDistribution_ADC->Write();
+  
+  
+  // -------------------------------------------------------------
+  // FAST threshold per strip (use TGraph for proper axes)
+  // -------------------------------------------------------------
+  TGraph* gFastThresh_LV = new TGraph();
+  TGraph* gFastThresh_HV = new TGraph();
+
+  gFastThresh_LV->SetName("FastThresh_LV");
+  gFastThresh_HV->SetName("FastThresh_HV");
+
+  // Axis titles
+  gFastThresh_LV->SetTitle("Fast Threshold per Strip;Strip;Threshold (keV)");
+
+  // Styling
+  gFastThresh_LV->SetMarkerStyle(20);   // circle
+  gFastThresh_LV->SetMarkerSize(1.0);
+  gFastThresh_LV->SetMarkerColor(kBlue);
+
+  gFastThresh_HV->SetMarkerStyle(20);   
+  gFastThresh_HV->SetMarkerSize(1.0);
+  gFastThresh_HV->SetMarkerColor(kRed);
+
+  // Fill graphs
+  for(const auto& kv : thresholds_TAC)
+  {
+    int strip = kv.first.strip;
+    char side = kv.first.side;
+    double thr = kv.second;
+
+    if(strip == 64) continue;
+
+    if(side == 'l')
+      gFastThresh_LV->SetPoint(gFastThresh_LV->GetN(), strip, thr);
+
+    if(side == 'h')
+    gFastThresh_HV->SetPoint(gFastThresh_HV->GetN(), strip, thr);
+  }
+
+  // Make sure ROOT file is the active directory
+  f.cd();
+  
+  // -------------------------------------------------------------
+  // Canvas with legend (FIXED VERSION)
+  // -------------------------------------------------------------
+  TCanvas* cFast = new TCanvas("cFastThresh","Fast Threshold per Strip",800,600);
+  cFast->cd();   
+
+  // Draw LV first 
+  gFastThresh_LV->Draw("AP");
+
+  // Force axis AFTER draw
+  gFastThresh_LV->GetYaxis()->SetRangeUser(0, 60);
+
+  // Draw HV
+  gFastThresh_HV->Draw("P SAME");
+
+  // Create legend AFTER graphs are drawn
+  TLegend* leg = new TLegend(0.7,0.72,0.8,0.8);
+  leg->AddEntry(gFastThresh_LV, "LV", "p");
+  leg->AddEntry(gFastThresh_HV, "HV", "p");
+
+  // Make legend clearly visible
+  leg->SetBorderSize(1);
+  leg->SetFillColor(0);
+  leg->SetTextSize(0.025);
+
+  leg->Draw();
+  cFast->GetListOfPrimitives()->Add(leg);
+
+  // force rendering
+  cFast->Modified();
+  cFast->Update();
+
+  // Write AFTER everything is finalized
+  cFast->Write();
+  
+  gFastThresh_LV->Write();
+  gFastThresh_HV->Write();
+  
+  
+  /* ------------------------------------------------------------- */
+  /* Build Slow vs TAC comparison                                  */
+  /* ------------------------------------------------------------- */
+
+  for(const auto& kv : thresholds)
+  {
+    StripKey key = kv.first;
+
+    if(thresholds_TAC.find(key) == thresholds_TAC.end())
+      continue;
+
+    double slowE = kv.second;
+    double tacE  = thresholds_TAC[key];
+
+    if(slowE > 0 && tacE > 0)
+    {
+      slowEnergyVec.push_back(slowE);
+      tacEnergyVec.push_back(tacE);
+    }
+  }
+
+  TGraph Slow_vs_TAC(
+    slowEnergyVec.size(),
+    slowEnergyVec.data(),
+    tacEnergyVec.data());
+
+  Slow_vs_TAC.SetName("Slow_vs_TAC");
+  Slow_vs_TAC.SetTitle("Slow vs TAC Energy;Slow Energy (keV);TAC Energy (keV)");
+  Slow_vs_TAC.SetMarkerStyle(20);
+  Slow_vs_TAC.SetMarkerSize(1);
+
+  Slow_vs_TAC.Write();
+  
+  
+  /* ------------------------------------------------------------- */
+  /* dt0 vs dt1 diagnostic histogram                               */
+  /* ------------------------------------------------------------- */
+
+  
+  
+  for(auto& kv : timingCounts)
+  {
+    StripKey key = kv.first;
+    auto& adcMap = kv.second;
+
+    if(key.strip == 64)
+    {
+      continue;
+    }
+
+    string name0 = "dt0_" + to_string(key.det) + "_" + key.side + "_" + to_string(key.strip);
+    string name1 = "dt1_" + to_string(key.det) + "_" + key.side + "_" + to_string(key.strip);
+
+    TH1D* h0 = new TH1D(name0.c_str(), name0.c_str(), 500, 0, 100);
+    TH1D* h1 = new TH1D(name1.c_str(), name1.c_str(), 500, 0, 100);
+
+    for(auto& a : adcMap)
+    {
+      int adc = a.first;
+      int n0  = a.second.first;
+      int n1  = a.second.second;
+
+      //double energy = calib[key.det][key.side][key.strip].Evaluate(adc);
+      double energy = helperCal.ADCToEnergy(key.det, key.side, key.strip, adc);
+	  
+	  //h0->Fill(energy, n0);
+      double e0 = helperCal.ADCToEnergy(key.det, key.side, key.strip, adc);
+      double e1 = helperCal.ADCToEnergy(key.det, key.side, key.strip, adc + 1);
+
+      // distribute counts across the interval
+      int nSub = 5;  // small subdivision
+      for(int i = 0; i < nSub; ++i)
+      {
+        double e = e0 + (e1 - e0)*(i + 0.5)/nSub;
+        h0->Fill(e, n0 / (double)nSub);
+        h1->Fill(e, n1 / (double)nSub);
+      }
+	  
+	 // h1->Fill(energy, n1);
+    }
+
+    h0->SetLineColor(kRed);
+    h1->SetLineColor(kBlue);
+
+    // --- FAST threshold line (energy space) ---
+    if(thresholds_TAC_ADC.find(key) != thresholds_TAC_ADC.end())
+    {
+      double thr_adc = thresholds_TAC_ADC[key];
+      //double thr_keV = calib[key.det][key.side][key.strip].Evaluate(thr_adc);
+      double thr_keV = helperCal.ADCToEnergy(key.det, key.side, key.strip, thr_adc);
+	  
+      double maxY = max(h0->GetMaximum(), h1->GetMaximum());
+
+      TLine* line = new TLine(thr_keV, 0, thr_keV, maxY);
+      line->SetLineColor(kGreen+2);
+      line->SetLineWidth(2);
+      line->SetLineStyle(2); // optional (dashed)
+
+      h0->GetListOfFunctions()->Add(line);
+    }
+
+    h0->Write();
+    h1->Write();
+  }
+  
+  // -------------------------------------------------------------
+  // SLOW threshold pixel map (LV vs HV)
+  // -------------------------------------------------------------
+  TH2D* hSlowPixelMap = new TH2D(
+    "SlowThresholdPixelMap",
+    "Slow Threshold Pixel Map;LV Strip;HV Strip;Threshold Value [keV]",
+    64, -0.5, 63.5,   // LV: 0–63
+    61, -0.5, 63.5    // HV: 0–60
+  );
+
+  // Temporary storage
+  map<int,double> slowLV;
+  map<int,double> slowHV;
+
+  // Separate thresholds by side
+  for(const auto& kv : thresholds)
+  {
+    int strip = kv.first.strip;
+    char side = kv.first.side;
+    double thr = kv.second;
+
+    if(strip == 64) continue; // skip guard ring
+
+    if(side == 'l') slowLV[strip] = thr;
+    if(side == 'h') slowHV[strip] = thr;
+  }
+
+  // Fill pixel map (HV vs LV)
+  for(const auto& lv : slowLV)
+  {
+    int lv_strip = lv.first;
+    double lv_thr = lv.second;
+
+    for(const auto& hv : slowHV)
+    {
+      int hv_strip = hv.first;
+      double hv_thr = hv.second;
+
+      //double value = 0.5 * (lv_thr + hv_thr);  // average
+	  double value = std::max(lv_thr, hv_thr); // select the higher threshold value
+
+      //hSlowPixelMap->Fill(lv_strip, hv_strip, value);
+	  int binX = hSlowPixelMap->GetXaxis()->FindBin(lv_strip);
+      int binY = hSlowPixelMap->GetYaxis()->FindBin(hv_strip);
+
+      hSlowPixelMap->SetBinContent(binX, binY, value);
+    }
+  }
+
+  // -------------------------------------------------------------
+  // Draw heatmap
+  // -------------------------------------------------------------
+  TCanvas* cSlowPixel = new TCanvas("cSlowPixel","Slow Threshold Pixel Map",800,700);
+  cSlowPixel->cd();
+
+  gStyle->SetPalette(112);  // safe Viridis
+
+  hSlowPixelMap->SetStats(0);
+
+  // Flip Y-axis so 0 is at top (your requirement)
+  hSlowPixelMap->GetYaxis()->SetRangeUser(60.5, -0.5);
+
+  hSlowPixelMap->Draw("COLZ");
+
+  cSlowPixel->Write();
+  hSlowPixelMap->Write();
+  
+  
+  
+  
+  
+
+  f.Close();
+  /* ------------------------------------------------------------- */
+  /* Helpful ROOT instructions                                     */
+  /* ------------------------------------------------------------- */
+
+  cout<<endl;
+  cout<<"Diagnostics written to "<<outfile<<"_diagnostics.root"<<endl;
+  cout<<endl;
+
+  cout<<"Example ROOT commands for diagnostics:"<<endl;
+  cout<<"---------------------------------------"<<endl;
+
+  cout<<"Open file:"<<endl;
+  cout<<"  root -l "<<outfile<<"_diagnostics.root"<<endl;
+  cout<<endl;
+
+  cout<<"Slow threshold diagnostic plots:"<<endl;
+  cout<<"---------------------------------------"<<endl;
+
+  cout<<"Slow threshold distribution:"<<endl;
+  cout<<"  cSlowDist->Draw()"<<endl;
+  cout<<endl;
+
+  cout<<endl;
+  cout<<"Slow threshold vs strip:"<<endl;
+  cout<<"  cSlowThresh->Draw()"<<endl;
+  cout<<endl;
+  
+  cout<<"Example energy spectrum with threshold:"<<endl;
+  cout<<"  Energy_0_h_10->Draw()"<<endl;
+  cout<<"  Energy_0_h_10->GetXaxis()->SetRangeUser(0,30)"<<endl;
+  cout<<endl;
+
+  cout<<"Pixel threshold heat maps:"<<endl;
+  cout<<"  cSlowPixel->Draw()"<<endl;
+  cout<<endl;
+  
+  
+  
+  cout<<endl;
+  cout<<"FAST threshold diagnostics:"<<endl;
+  cout<<"---------------------------------------"<<endl;
+
+  cout<<"Fast threshold distribution (keV):"<<endl;
+  cout<<"  cFastDist->Draw()"<<endl;
+  cout<<endl;
+
+  cout<<"HV and LV FAST thresholds:"<<endl;
+  cout<<"  cFastThresh->Draw()"<<endl;
+  cout<<endl;
+  
+  cout<<"Fast threshold diagnostic; single channel (dt0 vs dt1):"<<endl;
+  cout<<"  dt0_0_l_10->Draw()"<<endl;
+  cout<<"  dt1_0_l_10->SetLineColor(kBlue)"<<endl;
+  cout<<"  dt1_0_l_10->Draw(\"SAME\")"<<endl;
+  cout<<endl;
+  
+  
+  return 0;
+}
+
diff --git a/apps/StripEnergyThresholdFinder_config.yaml b/apps/StripEnergyThresholdFinder_config.yaml
new file mode 100644
index 00000000..ce6285a1
--- /dev/null
+++ b/apps/StripEnergyThresholdFinder_config.yaml
@@ -0,0 +1,18 @@
+input:
+  data_files:
+    - /path/to/data/file.hdf5
+
+  calibration_file: /path/to/calibration/file.ecal
+  tac_calibration_file: /path/to/tac/calibration/file.csv
+  strip_map: /path/to/strip/map/file.map
+
+analysis:
+  min_entries: 10 # number of skipped strips with minum statistics
+  fallback_threshold_keV: 20 # If a threshold cannot be determined set threshold to default value
+  # limit for locating the low-energy noise peak
+  # most noise peaks should be between 100 and 250
+  # Worst case the ADC max should be set to ~1000  
+  noise_search_max_adc: 1800 # Limits peak search to a specific reagion before gamma peaks
+  
+output:
+  prefix: output_file_prefix
\ No newline at end of file

From 2f699ef0bbb5cbe5ee933322685350d67105cba2 Mon Sep 17 00:00:00 2001
From: Jarred Roberts <jarredroberts24@gmail.com>
Date: Mon, 22 Jun 2026 22:18:21 -0700
Subject: [PATCH 2/2] Add StripEnergyThresholdFinder for per-strip slow and
 fast threshold extraction

---
 apps/StripEnergyThresholdFinder     |  Bin 0 -> 198944 bytes
 apps/StripEnergyThresholdFinder.cxx | 1353 +++++++++++++++------------
 2 files changed, 753 insertions(+), 600 deletions(-)
 create mode 100755 apps/StripEnergyThresholdFinder

diff --git a/apps/StripEnergyThresholdFinder b/apps/StripEnergyThresholdFinder
new file mode 100755
index 0000000000000000000000000000000000000000..2fce71ea5d302231dd204358144b00de2c6f3c0b
GIT binary patch
literal 198944
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%0A+x~Gpttb$0Vfv
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

literal 0
HcmV?d00001

diff --git a/apps/StripEnergyThresholdFinder.cxx b/apps/StripEnergyThresholdFinder.cxx
index 642715ac..60661f3c 100644
--- a/apps/StripEnergyThresholdFinder.cxx
+++ b/apps/StripEnergyThresholdFinder.cxx
@@ -257,10 +257,14 @@ class TACCalHelper
 
 bool PassHitSelection(MStripHit* SH)
 {
-  if(SH==nullptr) return false;
+  if (SH == nullptr) return false;
 
-  if(SH->IsGuardRing()) return true;
-  if(SH->IsNearestNeighbor()) return false;
+  // Basic sanity checks only
+  if (SH->GetStripID() < 0) return false;
+  if (SH->GetDetectorID() < 0) return false;
+
+  // Require signal
+  if (SH->GetADCUnits() <= 0) return false;
 
   return true;
 }
@@ -268,65 +272,171 @@ bool PassHitSelection(MStripHit* SH)
 
 
 
-int main(int argc,char** argv)
-{ 
+//! Finds per-strip slow and fast energy thresholds for germanium detectors
+class MStripThresholdFinder
+{
+public:
+  MStripThresholdFinder() {}
+
+  bool ParseCommandLine(int Argc, char** Argv);
+  bool BuildHistograms();
+
+  void FindSlowThresholds();
+  void FindFastThresholds();
+
+  void WriteCSV() const;
+  void WriteDiagnostics() const;
+  
+  MString GetOutputPrefix() const { return m_OutputPrefix; }
+
+private:
+
+  // --- Configuration ---
+  EnergyCalHelper m_EnergyCal;
+  vector<string> m_InputFiles;
+  MString m_CalibrationFile;
+  MString m_TACCalibrationFile;
+  MString m_StripMapFile;
+  MString m_OutputPrefix;
+
+  int m_MinEntries = 10;
+  double m_FallbackThreshold = 20.0;
+
+  int m_HistogramBins = 2048;
+  double m_HistogramMaxADC = 4096.0;
+  double m_NoiseSearchMaxADC = 2200.0;
+
+  long m_MaxEvents = -1;
+
+  // --- Data ---
+  map<StripKey, TH1D*> m_ADCHistograms;
+  map<StripKey, map<int, pair<int,int>>> m_TimingCounts;
+  
+  map<StripKey, TH1D*> dt0_hists;
+  map<StripKey, TH1D*> dt1_hists;
 
-  // Force unbuffered stdout so progress bar updates live
+  // --- Results ---
+  map<StripKey, double> m_SlowThresholds;
+  map<StripKey, double> m_SlowThresholdsADC;
+
+  map<StripKey, double> m_FastThresholds;
+  map<StripKey, double> m_FastThresholdsADC;
+
+  // --- Helpers ---
+  int FindNoisePeakBin(TH1D* Histogram) const;
+  int FindThresholdBin(TH1D* Histogram, int PeakBin) const;
+  int FindCrossoverADC(const map<int, pair<int,int>>& ADCMap, int FirstNonzero) const;
+  
+  // --- Diagnostics (temporary restore for plotting) ---
+  vector<double> m_stripIndex_LV;
+  vector<double> m_stripIndex_HV;
+
+  vector<double> m_thresholdValues_LV;
+  vector<double> m_thresholdValues_HV;
+  
+  
+};
+
+
+
+
+
+int main(int Argc, char** Argv)
+{
   setvbuf(stdout, NULL, _IONBF, 0);
+  MGlobal::Initialize("Standalone", "ThresholdFinder");
+
+  MStripThresholdFinder Finder;
+
+  if (!Finder.ParseCommandLine(Argc, Argv)) return 1;
+  if (!Finder.BuildHistograms()) return 1;
+
+  Finder.FindSlowThresholds();
+  Finder.FindFastThresholds();
+
+  Finder.WriteCSV();
+  Finder.WriteDiagnostics();
+  
   
   /* ------------------------------------------------------------- */
-  /* We Include this help menu so that users can define their      */
-  /* Variables,, without needing a yaml config file                */
+  /* Helpful ROOT instructions                                     */
   /* ------------------------------------------------------------- */
 
-  for(int i=1;i<argc;i++)
-  {
-    string arg = argv[i];
+  cout<<endl;
+  cout<<"Diagnostics written to "
+      << Finder.GetOutputPrefix()
+      << "_diagnostics.root"<<endl;
+  cout<<endl;
 
-    if(arg == "--help" || arg == "-h")
-    {
-      cout<<endl;
-      cout<<"StripEnergyThresholdFinder"<<endl;
-      cout<<endl;
-      cout<<"Usage:"<<endl;
-      cout<<"  ./StripEnergyThresholdFinder config.yaml [options]"<<endl;
-      cout<<endl;
-      cout<<"Options:"<<endl;
-	  cout<<"Input/Output overrides:"<<endl;
-      cout<<"  --data_file FILE            Add data file (can be used multiple times)"<<endl;
-      cout<<"  --calibration_file FILE"<<endl;
-      cout<<"  --strip_map FILE"<<endl;
-      cout<<"  --output_prefix NAME"<<endl;
-      cout<<endl;
-      cout<<"  --min_entries N              Minimum entries required in strip histogram"<<endl;
-      cout<<"  --noise_search_max_adc N     Maximum ADC value used when locating noise peak"<<endl;
-      cout<<"  --fallback_threshold_keV N   Threshold assigned if algorithm fails"<<endl;
-      cout<<"  --help                       Show this help menu"<<endl;
-      cout<<endl;
-      cout<<"Example:"<<endl;
-      cout<<"  ./StripEnergyThresholdFinder config.yaml --noise_search_max_adc 1800"<<endl;
-      cout<<endl;
-      return 0;
-    }
-  }
-   
-  //TH1::AddDirectory(false);
-  MGlobal::Initialize("Standalone","ThresholdFinder");
+  cout<<"Example ROOT commands for diagnostics:"<<endl;
+  cout<<"---------------------------------------"<<endl;
+
+  cout<<"Open file:"<<endl;
+  cout<<"  root -l "<<Finder.GetOutputPrefix()<<"_diagnostics.root"<<endl;
+  cout<<endl;
+
+  cout<<"Slow threshold diagnostic plots:"<<endl;
+  cout<<"---------------------------------------"<<endl;
+
+  cout<<"Slow threshold distribution:"<<endl;
+  cout<<"  cSlowDist->Draw()"<<endl;
+  cout<<endl;
+
+  cout<<endl;
+  cout<<"Slow threshold vs strip:"<<endl;
+  cout<<"  cSlowThresh->Draw()"<<endl;
+  cout<<endl;
+  
+  cout<<"Example energy spectrum with threshold:"<<endl;
+  cout<<"  Energy_0_h_10->Draw()"<<endl;
+  cout<<"  Energy_0_h_10->GetXaxis()->SetRangeUser(0,30)"<<endl;
+  cout<<endl;
 
-  if(argc<2)
+  cout<<"Pixel threshold heat maps:"<<endl;
+  cout<<"  cSlowPixel->Draw()"<<endl;
+  cout<<endl;
+  
+  
+  
+  cout<<endl;
+  cout<<"FAST threshold diagnostics:"<<endl;
+  cout<<"---------------------------------------"<<endl;
+
+  cout<<"Fast threshold distribution (keV):"<<endl;
+  cout<<"  cFastDist->Draw()"<<endl;
+  cout<<endl;
+
+  cout<<"HV and LV FAST thresholds:"<<endl;
+  cout<<"  cFastThresh->Draw()"<<endl;
+  cout<<endl;
+  
+  cout << "dt0 vs dt1 with fast threshold:" << endl;
+  cout << "  cFast_0_l_10->Draw();" << endl;
+
+
+  return 0;
+}
+
+
+bool MStripThresholdFinder::ParseCommandLine(int argc, char** argv)
+{
+  if(argc < 2)
   {
-    cout<<"Usage: ./StripEnergyThresholdFinder config.yaml"<<endl;
-    return -1;
+    cout << "Usage: ./StripEnergyThresholdFinder config.yaml" << endl;
+    return false;
   }
+  
+
+
+  string configFile = argv[1];
+  YAML::Node config = YAML::LoadFile(configFile);
 
-  string configFile=argv[1];
-  YAML::Node config=YAML::LoadFile(configFile);
 
   int minEntries=10;
   double fallbackThreshold=20;
-  int histogramBins=2048;
-  double histogramMaxADC=4096;
-  double noise_search_max_adc=2200;
+  m_HistogramBins=2048;
+  m_HistogramMaxADC=4096;
+  m_NoiseSearchMaxADC=2200;
   
   /* ------------------------------------------------------------- */
   /* Command line override parameters (optional)                   */
@@ -355,35 +465,38 @@ int main(int argc,char** argv)
       fallbackThreshold=config["analysis"]["fallback_threshold_keV"].as<double>();
 
     if(config["analysis"]["histogram_bins"])
-      histogramBins=config["analysis"]["histogram_bins"].as<int>();
+      m_HistogramBins = config["analysis"]["histogram_bins"].as<int>();
 
     if(config["analysis"]["histogram_max_adc"])
-      histogramMaxADC=config["analysis"]["histogram_max_adc"].as<double>();
+      m_HistogramMaxADC = config["analysis"]["histogram_max_adc"].as<double>();
 
     if(config["analysis"]["noise_search_max_adc"])
-      noise_search_max_adc=config["analysis"]["noise_search_max_adc"].as<double>();
+      m_NoiseSearchMaxADC = config["analysis"]["noise_search_max_adc"].as<double>();
   }
 
 
-  vector<string> inputFiles=config["input"]["data_files"].as<vector<string>>();
   
-  if (inputFiles.empty()) {
+  m_InputFiles = config["input"]["data_files"].as<vector<string>>();
+  
+  if (m_InputFiles.empty()) 
+  {
     cerr << "Error: No input files provided." << endl;
     return 1;
   }
   
-  string calibrationFile=config["input"]["calibration_file"].as<string>();
-  string stripMapFileStr=config["input"]["strip_map"].as<string>();
-  string outfile=config["output"]["prefix"].as<string>();
+  
+  m_CalibrationFile = config["input"]["calibration_file"].as<string>().c_str();
+  m_StripMapFile = config["input"]["strip_map"].as<string>().c_str();
+  m_OutputPrefix = config["output"]["prefix"].as<string>().c_str();
 
 
-  EnergyCalHelper helperCal;
-  TACCalHelper helperCal_TAC;
+  //EnergyCalHelper m_EnergyCal;
+  TACCalHelper m_EnergyCal_TAC;
   
-  if(!helperCal.Load(calibrationFile))
+  if(!m_EnergyCal.Load(m_CalibrationFile.Data()))
   {
-    cout<<"Failed to load calibration file: "<<calibrationFile<<endl;
-    return -1;
+    cout<<"Failed to load calibration file: "<<m_CalibrationFile.Data()<<endl;
+    return false;
   }
   
   string tacCalibrationFile = config["input"]["tac_calibration_file"].as<string>();
@@ -430,11 +543,8 @@ int main(int argc,char** argv)
         cmd_fallback_threshold_keV = atof(optarg);
         break;
 		
-	  //case 'd':
-        //cmd_data_file = optarg;
-        //break;
       case 'd':
-        inputFiles.push_back(optarg);
+        m_InputFiles.push_back(optarg);
         break;
 		
 	  case 'e':
@@ -484,191 +594,363 @@ int main(int argc,char** argv)
 
   if(cmd_calibration_file != "")
   {
-    calibrationFile = cmd_calibration_file;
+    m_CalibrationFile = cmd_calibration_file;
   }
 
   if(cmd_strip_map != "")
   {
-    stripMapFileStr = cmd_strip_map;
+    m_StripMapFile = cmd_strip_map;
   }
 
   if(cmd_output_prefix != "")
   {
-    outfile = cmd_output_prefix;
+    m_OutputPrefix = cmd_output_prefix;
   } 
   
   // Determine output directory from first data file
-  fs::path dataPath(inputFiles.back());
+  fs::path dataPath(m_InputFiles.back());
   fs::path outputDir = dataPath.parent_path();
 
-  // Resolve outfile path
-  fs::path outPath(outfile);
+  // Resolve m_OutputPrefix path
+  fs::path outPath(m_OutputPrefix.Data());
 
   if (!outPath.is_absolute())
   {
-    outfile = (outputDir / outPath).string();
+    m_OutputPrefix = (outputDir / outPath).string();
   }
-  //outfile = fs::weakly_canonical(outfile).string();
 
   // Debug print
-  cout << "Resolved output prefix: " << outfile << endl;
+  cout << "Resolved output prefix: " << m_OutputPrefix << endl;
   
-  MString stripMapFile = stripMapFileStr.c_str();
-
-  /* ------------------------------------------------------------- */
-  /* Apply command line overrides if provided                      */
-  /* ------------------------------------------------------------- */
-
-  if(cmd_min_entries >= 0)
-    minEntries = cmd_min_entries;
-
-  if(cmd_noise_search_max_adc > 0)
-    noise_search_max_adc = cmd_noise_search_max_adc;
-
-  if(cmd_fallback_threshold_keV > 0)
-    fallbackThreshold = cmd_fallback_threshold_keV;
-
-
-  MSupervisor* S=MSupervisor::GetSupervisor();
-
-  map<StripKey,TH1D*> histograms;
-  map<StripKey,TH1D*> histograms_TAC;
-  
-  map<StripKey, map<int, pair<int,int>>> timingCounts;
   
   /* ------------------------------------------------------------- */
   /* Save configuration to log file                                */
   /* ------------------------------------------------------------- */
   
   cout<<endl;
-  cout<<"  calibration_file:        "<<calibrationFile<<endl;
-  cout<<"  strip_map:               "<<stripMapFileStr<<endl;
-  cout<<"  output_prefix:           "<<outfile<<endl;
+  cout<<"  calibration_file:        "<<m_CalibrationFile.Data()<<endl;
+  cout<<"  strip_map:               "<<m_StripMapFile<<endl;
+  cout<<"  output_prefix:           "<<m_OutputPrefix<<endl;
 
   cout<<"  data_files:"<<endl;
-  for(auto &f : inputFiles)
+  for(auto &f : m_InputFiles)
       cout<<"    "<<f<<endl;
 
   cout<<endl;
   cout<<"Active analysis configuration:"<<endl;
-  cout<<"  min_entries:            "<<minEntries<<endl;
-  cout<<"  fallback_threshold_keV: "<<fallbackThreshold<<endl;
-  cout<<"  noise_search_max_adc:   "<<noise_search_max_adc<<endl;
-  cout<<"  histogram_bins:         "<<histogramBins<<endl;
-  cout<<"  histogram_max_adc:      "<<histogramMaxADC<<endl;
+  cout<<"  min_entries:            "<<m_MinEntries<<endl;
+  cout<<"  fallback_threshold_keV: "<<m_FallbackThreshold<<endl;
+  cout<<"  NoiseSearchMaxADC:      "<<m_NoiseSearchMaxADC<<endl;
+  cout<<"  histogram_bins:         "<<m_HistogramBins<<endl;
+  cout<<"  histogram_max_adc:      "<<m_HistogramMaxADC<<endl;
   cout<<endl;
+  
+  MString stripMapFile = m_StripMapFile.Data() ;
+  
+
 
+  return true;
+}
+
+
+
+bool MStripThresholdFinder::BuildHistograms()
+{ 
+  MString stripMapFile = m_StripMapFile;
+  long max_events = m_MaxEvents;  
+
+  //map<StripKey,TH1D*> histograms;
+  map<StripKey, vector<int>> hist_counts;
+  map<StripKey, vector<int>> dt0_counts;
+  map<StripKey, vector<int>> dt1_counts;  
+  map<StripKey, double> adc_to_keV_scale;
+  map<StripKey,TH1D*> histograms_TAC;
+
+  map<StripKey, map<int, pair<int,int>>> timingCounts;
 
   /* ------------------------------------------------------------- */
   /* Build ADC histograms from data                                */
   /* ------------------------------------------------------------- */
+    
+	MModuleLoaderMeasurementsHDF* Loader = new MModuleLoaderMeasurementsHDF();
 
-  for(string inputFile:inputFiles)
-  {
-
-    MModuleLoaderMeasurementsHDF* Loader=new MModuleLoaderMeasurementsHDF();
-    Loader->SetFileName(inputFile.c_str());
-    Loader->SetFileNameStripMap(stripMapFile);
+    Loader->SetFileName(m_InputFiles[0].c_str());
 
-    S->SetModule(Loader,0);
+	cout << "Loading file: " << m_InputFiles[0] << endl;
+	cout << "Number of input files: " << m_InputFiles.size() << endl;
+	
+    Loader->SetFileNameStripMap(m_StripMapFile.Data());
 
-    if(!Loader->Initialize()) return -1;
+	MSupervisor* S = MSupervisor::GetSupervisor();
+    S->SetModule(Loader, 0);
 
+    if (!Loader->Initialize())
+    {
+      cerr << "Failed to initialize loader!" << endl;
+      return false;
+    }
+	
+	
+	
     MReadOutAssembly* Event=new MReadOutAssembly();
     
 	long event_counter = 0;
-    while(Loader->IsFinished()==false)
+	
+	while (Loader->IsFinished() == false)
     {
-      if(max_events > 0 && event_counter >= max_events)
+		
+	
+	  
+      if (max_events > 0 && event_counter >= max_events)
         break;
-	  Event->Clear();
 
-      if(Loader->IsReady())
+      Event->Clear();
+
+      if (Loader->IsReady())
       {
         Loader->AnalyzeEvent(Event);
-		event_counter++;
-
-        for(unsigned int sh=0;sh<Event->GetNStripHits();sh++)
+        event_counter++;
+		
+        // -------------------------------------------------------------
+        // GLOBAL progress bar (event processing)
+        // -------------------------------------------------------------
+        if (event_counter % 10000 == 0)
         {
-          MStripHit* SH=Event->GetStripHit(sh);
+          int barWidth = 40;
 
-          if(!PassHitSelection(SH)) continue;
+          // If we know total → real progress
+          if (max_events > 0)
+          {
+            float progress = (float)event_counter / max_events;
 
-          double adc=SH->GetADCUnits();
-		  
-		  int det=SH->GetDetectorID();
-          int strip=SH->GetStripID();
-          char side=SH->IsLowVoltageStrip()?'l':'h';
-		  
-		  StripKey key{det,side,strip};
-		  
-		  /* ------------------------------------------------------------- */
-          /* Fast threshold data accumulation (dt0 vs dt1)                 */
-          /* ------------------------------------------------------------- */
+            cout << "\r[";
+            int pos = barWidth * progress;
+
+            for (int i = 0; i < barWidth; ++i)
+            {
+              if (i < pos) cout << "=";
+              else if (i == pos) cout << ">";
+              else cout << " ";
+            }
 
-          int adc_int = (int)adc;
+            cout << "] " << int(progress * 100.0) << "%";
+          }
+          else
+          {
+            // -------------------------------------------------------------
+            // UNKNOWN TOTAL → animated progress bar
+            // -------------------------------------------------------------
+            int pos = (event_counter / 10000) % barWidth;
 
-          // Define timing type
-          int timing_type = SH->HasFastTiming() ? 1 : 0;
+            cout << "\r[";
 
-          // Accumulate counts
-          auto& entry = timingCounts[key][adc_int];
+            for (int i = 0; i < barWidth; ++i)
+            {
+              if (i == pos) cout << ">";
+              else cout << " ";
+            }
 
-          if(timing_type == 0)
-            entry.first++;
-          else
-            entry.second++;
-		  
-		  /* ------------------------------------------------------------- */
-          /* TAC (fast shaper) histogram filling                           */
-          /* ------------------------------------------------------------- */
+            cout << "] events: " << event_counter;
+          }
+
+          cout << flush;      
+        }
+
+
+
+        int NStrips = Event->GetNStripHits();
+
+        for (int i = 0; i < NStrips; ++i)
+        {
+          MStripHit* SH = Event->GetStripHit(i);
+
+          if (!PassHitSelection(SH)) continue;
 
-          if(SH->HasFastTiming() && SH->GetTAC() > 0)
+          double adc = SH->GetADCUnits();
+          int det = SH->GetDetectorID();
+          int strip = SH->GetStripID();
+          char side = SH->IsLowVoltageStrip() ? 'l' : 'h';
+
+          StripKey key{det, side, strip};
+		  
+		  // -------------------------------------------------------------
+          // Precompute ADC→keV scale (once per strip)
+          // -------------------------------------------------------------
+          if (adc_to_keV_scale.find(key) == adc_to_keV_scale.end())
           {
-            double tac = SH->GetTAC();
+            // approximate slope using ADC=0 → ADC=1000
+            double e0 = m_EnergyCal.ADCToEnergy(det, side, strip, 0);
+            double e1 = m_EnergyCal.ADCToEnergy(det, side, strip, 1000);
 
-            //StripKey key{det,side,strip};
+            adc_to_keV_scale[key] = (e1 - e0) / 1000.0;
+          }
+		 
 
-            if(histograms_TAC[key]==nullptr)
-            {
-              string name="h_TAC_"+to_string(det)+"_"+side+"_"+to_string(strip);
 
-              histograms_TAC[key]=new TH1D(
-                name.c_str(),
-                name.c_str(),
-                histogramBins,0,histogramMaxADC);
+          //it_hist->second->Fill(adc);
+		  int bin = (int)(adc / m_HistogramMaxADC * m_HistogramBins);
 
-              histograms_TAC[key]->GetXaxis()->SetTitle("TAC ADC");
-              histograms_TAC[key]->GetYaxis()->SetTitle("Counts");
+          if (bin >= 0 && bin < m_HistogramBins)
+          {
+            if (hist_counts.find(key) == hist_counts.end())
+            {
+              hist_counts[key] = vector<int>(m_HistogramBins, 0);
             }
 
-            histograms_TAC[key]->Fill(tac);
+            hist_counts[key][bin]++;
           }
-		  
-		  
-		  
-		  static int debugCounter = 0;
+		  		  
+		  // -------------------------------------------------------------
+          // FAST timing accumulation (dt0 vs dt1)
+          // -------------------------------------------------------------
 
-          if(histograms[key]==nullptr)
-          {
-            string name="h_"+to_string(det)+"_"+side+"_"+to_string(strip);
+          int adc_bin = static_cast<int>(adc);
+      	  
+		  double tac = SH->GetTAC();
 
-            histograms[key]=new TH1D(name.c_str(),name.c_str(),
-                                     histogramBins,0,histogramMaxADC);
+          // --- dt0 vs dt1 separation ---
+          bool is_dt1 = (tac > 8000);   // initial threshold
 
-            histograms[key]->GetXaxis()->SetTitle("ADC");
-            histograms[key]->GetYaxis()->SetTitle("Counts");
+
+          // Initialize bin if needed
+          if (timingCounts[key].find(adc_bin) == timingCounts[key].end())
+          {
+            timingCounts[key][adc_bin] = {0, 0};
           }
 
-          histograms[key]->Fill(adc);
+
+          double energy = adc * adc_to_keV_scale[key];
+
+		  
+		  int ebin = (int)(energy / (adc_to_keV_scale[key] * m_HistogramMaxADC) * m_HistogramBins);
+
+          if (ebin >= 0 && ebin < m_HistogramBins)
+          {
+            if (is_dt1)
+            {
+              timingCounts[key][adc_bin].second++;
+
+              auto& counts = dt1_counts[key];
+              if (counts.empty()) counts.resize(m_HistogramBins, 0);
+              counts[ebin]++;
+            }
+            else
+            {
+              timingCounts[key][adc_bin].first++;
+
+              auto& counts = dt0_counts[key];
+              if (counts.empty()) counts.resize(m_HistogramBins, 0);
+              counts[ebin]++;
+            }
+          }		  
         }
       }
     }
+    cout << endl;
+
+  // Save into class
+
+  
+  for (auto& kv : hist_counts)
+  {
+    StripKey key = kv.first;
+    vector<int>& counts = kv.second;
+
+    string name = "h_" + to_string(key.det) + "_" + key.side + "_" + to_string(key.strip);
+
+    TH1D* h = new TH1D(
+      name.c_str(),
+      name.c_str(),
+      m_HistogramBins,
+      0,
+      m_HistogramMaxADC
+    );
+
+    for (int i = 0; i < m_HistogramBins; ++i)
+    {
+      h->SetBinContent(i+1, counts[i]);
+    }
+
+    m_ADCHistograms[key] = h;
+  }
+  
+  // -------------------------------------------------------------
+  // Rebuild dt0 histograms
+  // -------------------------------------------------------------
+  for (auto& kv : dt0_counts)
+  {
+    StripKey key = kv.first;
+    vector<int>& counts = kv.second;
+
+    double maxE = m_EnergyCal.ADCToEnergy(key.det, key.side, key.strip, m_HistogramMaxADC);
+
+    string name = "dt0_" + to_string(key.det) + "_" + key.side + "_" + to_string(key.strip);
+
+    TH1D* h = new TH1D(
+      name.c_str(),
+      name.c_str(),
+      m_HistogramBins,
+      0,
+      maxE
+    );
+
+    for (int i = 0; i < m_HistogramBins; ++i)
+    {
+      h->SetBinContent(i+1, counts[i]);
+    }
 
-    delete Event;
+    dt0_hists[key] = h;
   }
 
 
+  // -------------------------------------------------------------
+  // Rebuild dt1 histograms
+  // -------------------------------------------------------------
+  for (auto& kv : dt1_counts)
+  {
+    StripKey key = kv.first;
+    vector<int>& counts = kv.second;
+
+    double maxE = m_EnergyCal.ADCToEnergy(key.det, key.side, key.strip, m_HistogramMaxADC);
+
+    string name = "dt1_" + to_string(key.det) + "_" + key.side + "_" + to_string(key.strip);
+
+    TH1D* h = new TH1D(
+      name.c_str(),
+      name.c_str(),
+      m_HistogramBins,
+      0,
+      maxE
+    );
+
+    for (int i = 0; i < m_HistogramBins; ++i)
+    {
+      h->SetBinContent(i+1, counts[i]);
+    }
+
+    dt1_hists[key] = h;
+  }
+  
+  
+  m_TimingCounts = timingCounts;
+  
+
+
+  return true;
+  
+}
+
+
+
+void MStripThresholdFinder::FindSlowThresholds()
+{
+
+  m_stripIndex_LV.clear();
+  m_stripIndex_HV.clear();
+  m_thresholdValues_LV.clear();
+  m_thresholdValues_HV.clear();
+
+
   /* ------------------------------------------------------------- */
   /* Threshold finding algorithm                                   */
   /* ------------------------------------------------------------- */
@@ -677,7 +959,7 @@ int main(int argc,char** argv)
   map<StripKey,double> thresholdsADC;
   
   // Progress tracking (slow thresholds)
-  int totalStrips = histograms.size();
+  int totalStrips = m_ADCHistograms.size();
   int processedStrips = 0;
 
   map<int,double> thresholdLV;
@@ -686,22 +968,12 @@ int main(int argc,char** argv)
   map<int,double> thresholdLV_ADC;
   map<int,double> thresholdHV_ADC;
   
-  /* ------------------------------------------------------------- */
-  /* Fast shaper (TAC) histograms                                  */
-  /* ------------------------------------------------------------- */
-
-  //map<StripKey,TH1D*> histograms_TAC;
   
   /* ------------------------------------------------------------- */
   /* TAC threshold storage                                         */
   /* ------------------------------------------------------------- */
-
-  map<StripKey,double> thresholds_TAC;
-  map<StripKey,double> thresholds_TAC_ADC;
-  //map<StripKey, map<int, pair<int,int>>> timingCounts;
   
-  
-  /* HV/LV split */
+  // HV/LV split 
 
   map<int,double> thresholdLV_TAC;
   map<int,double> thresholdHV_TAC;
@@ -730,40 +1002,34 @@ int main(int argc,char** argv)
   vector<double> thresholdValues_LV;
   vector<double> thresholdValues_HV;
 
-  vector<double> noisePeakADC_LV;
-  vector<double> noisePeakADC_HV;
-  
+
   /* ------------------------------------------------------------- */
   /* TAC diagnostic vectors                                        */
   /* ------------------------------------------------------------- */
 
-  vector<double> stripIndex_TAC_LV;
-  vector<double> stripIndex_TAC_HV;
-
   vector<double> thresholdValues_TAC_LV;
   vector<double> thresholdValues_TAC_HV;
 
   vector<double> tacPeakADC_LV;
   vector<double> tacPeakADC_HV;
   
-  vector<double> slowEnergyVec;
-  vector<double> tacEnergyVec;
 
-  for(auto& kv:histograms)
-  {
 
+  for(auto& kv : m_ADCHistograms)
+  {
+	
     StripKey key=kv.first;
     TH1D* hist=kv.second;
 
-    if(hist->GetEntries()<minEntries)
+    if(hist->GetEntries()<m_MinEntries)
     {
-      thresholds[key]=fallbackThreshold;
+      thresholds[key]=m_FallbackThreshold;
       continue;
     }
 
     hist->Smooth(3);
 
-    int maxSearchBin=hist->FindBin(noise_search_max_adc);
+    int maxSearchBin = hist->FindBin(m_NoiseSearchMaxADC);
 
     int startBin=-1;
 
@@ -772,7 +1038,7 @@ int main(int argc,char** argv)
 
     if(startBin<0)
     {
-      thresholds[key]=fallbackThreshold;
+      thresholds[key]=m_FallbackThreshold;
       continue;
     }
 
@@ -822,74 +1088,78 @@ int main(int argc,char** argv)
 
     /* Convert ADC → keV using SLOW calibration */
     double thresholdKeV =
-      helperCal.ADCToEnergy(key.det,key.side,key.strip,thresholdADC);
-
-    /* Store SLOW thresholds */
+      m_EnergyCal.ADCToEnergy(key.det,key.side,key.strip,thresholdADC);
+    
+	if(key.side == 'l')
+    {
+      m_stripIndex_LV.push_back(key.strip);
+      m_thresholdValues_LV.push_back(thresholdKeV);
+    }
+    else if(key.side == 'h')
+    {
+      m_stripIndex_HV.push_back(key.strip);
+      m_thresholdValues_HV.push_back(thresholdKeV);
+    }
+	
+	
+	
+    // Store SLOW thresholds 
     thresholds[key] = thresholdKeV;
     thresholdsADC[key] = thresholdADC;
 	
 	// Progress bar update
-    processedStrips++;
-
-    int barWidth = 40;
-    float progress = (float)processedStrips / totalStrips;
+    //processedStrips++;
 
-    cout << "\r[";
-    int pos = barWidth * progress;
+    //int barWidth = 40;
+    //if (totalStrips == 0) totalStrips = 1;
+    //float progress = (float)processedStrips / totalStrips;
+	
+	
+	
+    //cout << "\r[";
+    //int pos = barWidth * progress;
 
-    for(int i = 0; i < barWidth; ++i)
-    {
-      if(i < pos) cout << "=";
-      else if(i == pos) cout << ">";
-      else cout << " ";
-    }
+    //for(int i = 0; i < barWidth; ++i)
+    //{
+    //  if(i < pos) cout << "=";
+    //  else if(i == pos) cout << ">";
+    //  else cout << " ";
+    //}
 
-    cout << "] " << int(progress * 100.0) << "%" << flush;
+    //cout << "] " << int(progress * 100.0) << "%" << flush;
+	
+  }
+  cout << endl;
 
-    /* ------------------------------------------------------------- */
-    /* Store values for diagnostic plots                             */
-    /* ------------------------------------------------------------- */
+  // Save results into class members
+  m_SlowThresholds = thresholds;
+  m_SlowThresholdsADC = thresholdsADC;
+  
+  
+  cout << "LV points: " << m_stripIndex_LV.size() << endl;
+  cout << "HV points: " << m_stripIndex_HV.size() << endl;
+}
 
-    stripIndex.push_back(key.strip);
-    thresholdValues.push_back(thresholdKeV);
-    noisePeakADC.push_back(hist->GetBinCenter(peakBin));
-	
-	/* -------------------------------------------------------------- */
-    /* Store HV and LV diagnostics separately so both appear in plots */
-    /* -------------------------------------------------------------- */
 
-    if(key.side=='l')
-    {
-        stripIndex_LV.push_back(key.strip);
-        thresholdValues_LV.push_back(thresholdKeV);
-        noisePeakADC_LV.push_back(hist->GetBinCenter(peakBin));
-    }
-    else
-    {
-        stripIndex_HV.push_back(key.strip);
-        thresholdValues_HV.push_back(thresholdKeV);
-        noisePeakADC_HV.push_back(hist->GetBinCenter(peakBin));
-    }
 
-    if(key.side=='l')
-    {
-	  thresholdLV[key.strip]=thresholdKeV;
-      thresholdLV_ADC[key.strip]=thresholdADC;
-    }
-    else
-    {
-      thresholdHV[key.strip]=thresholdKeV;
-      thresholdHV_ADC[key.strip]=thresholdADC;
-    }
-	
+void MStripThresholdFinder::FindFastThresholds()
+{
+  
+  if (m_TimingCounts.empty())
+  {
+    cout << "Warning: No timing data available for fast threshold calculation." << endl;
   }
-  cout << endl;
   
+  
+  //map<StripKey,double> m_FastThresholds;
+  map<StripKey,double> thresholds_TAC_ADC;
+  //map<StripKey,double> m_FastThresholdsADC;
+
   /* ------------------------------------------------------------- */
   /* Fast threshold finder (dt0 vs dt1 crossover)                  */
   /* ------------------------------------------------------------- */
 
-  for(auto& kv : timingCounts)
+  for(auto& kv : m_TimingCounts)
   {
     StripKey key = kv.first;
     auto& adcMap = kv.second;
@@ -904,17 +1174,18 @@ int main(int argc,char** argv)
     for(auto& a : adcMap)
       totalCounts += a.second.first + a.second.second;
 
-    //if(totalCounts < minEntries)
+    //if(totalCounts < m_MinEntries)
 		
-	// Proper minEntries guard
-    if(totalCounts < minEntries)
+	// Proper m_MinEntries guard
+    if(totalCounts < m_MinEntries)
     {
-      thresholds_TAC[key] = fallbackThreshold;
+      m_FastThresholds[key] = m_FallbackThreshold;
       continue;
     }
 
     // Find first nonzero ADC
     int first_nonzero = -1;
+	if (kv.second.empty()) continue;
 
     for(auto& a : adcMap)
     {
@@ -927,12 +1198,10 @@ int main(int argc,char** argv)
 
     if(first_nonzero < 0)
     {
-      thresholds_TAC[key] = fallbackThreshold;
+      m_FastThresholds[key] = m_FallbackThreshold;
       continue;
     }
 	
-	
-    //cout << "FAST threshold RMS  (keV): " << hFastThreshDist->GetRMS() << endl;
 
     int bestADC = -1;
     int minDiff = 1e9;
@@ -992,7 +1261,7 @@ int main(int argc,char** argv)
 
     if(bestADC < 0)
     {
-      thresholds_TAC[key] = fallbackThreshold;
+      m_FastThresholds[key] = m_FallbackThreshold;
       continue;
     }
 
@@ -1009,51 +1278,34 @@ int main(int argc,char** argv)
       // fallback to old method
       fast_thresh_adc = bestADC + nbins/2;
     }
-	
-	/*cout << "[FAST DEBUG] strip " << key.strip
-         << " bestADC=" << bestADC
-         << " crossoverADC=" << crossoverADC
-         << endl;*/
-
-    thresholds_TAC_ADC[key] = fast_thresh_adc;
-
-    double fast_thresh_keV =
-      helperCal.ADCToEnergy(key.det,key.side,key.strip,fast_thresh_adc);
 
-    thresholds_TAC[key] = fast_thresh_keV;
 
-    /* Store diagnostics */
+    m_FastThresholdsADC[key] = fast_thresh_adc;
 
-    if(key.side=='l')
-    {
-      stripIndex_TAC_LV.push_back(key.strip);
-      thresholdValues_TAC_LV.push_back(fast_thresh_keV);
-    }
-    else
-    {
-      stripIndex_TAC_HV.push_back(key.strip);
-      thresholdValues_TAC_HV.push_back(fast_thresh_keV);
-    }
+    double fast_thresh_keV =
+      m_EnergyCal.ADCToEnergy(key.det,key.side,key.strip,fast_thresh_adc);
 
-    /* Debug print */
+    m_FastThresholds[key] = fast_thresh_keV;
 
-    /*cout << "[FAST] DET " << key.det
-         << " " << key.side
-         << " strip " << key.strip
-         << " ADC: " << fast_thresh_adc
-         << " keV: " << fast_thresh_keV
-         << endl;*/
-    
   } 
+}
+
 
 
+void MStripThresholdFinder::WriteCSV() const
+{
+  
+  if (m_SlowThresholds.empty() && m_FastThresholds.empty())
+  {
+    cout << "Warning: No thresholds available to write to CSV." << endl;
+  }
   
   /* ------------------------------------------------------------- */
   /* Write CSV threshold tables (HV and LV)                        */
   /* ------------------------------------------------------------- */
 
-  ofstream csv_HV(outfile + "_Slow_HV_thresholds.csv");
-  ofstream csv_LV(outfile + "_Slow_LV_thresholds.csv");
+  ofstream csv_HV(m_OutputPrefix + "_Slow_HV_thresholds.csv");
+  ofstream csv_LV(m_OutputPrefix + "_Slow_LV_thresholds.csv");
 
   /* CSV headers */
 
@@ -1062,13 +1314,13 @@ int main(int argc,char** argv)
 
   /* Write rows */
 
-  for(const auto& kv : thresholds)
+  for(const auto& kv : m_SlowThresholds)
   {
     char side = kv.first.side;
     int strip = kv.first.strip;
 
     double thr_keV = kv.second;	
-	double thr_adc = thresholdsADC[kv.first];
+	double thr_adc = m_SlowThresholdsADC.at(kv.first);
     	
 	
 	if(side == 'h')
@@ -1088,46 +1340,7 @@ int main(int argc,char** argv)
   }
   
   
-  /* ------------------------------------------------------------- */
-  /* Pixel threshold maps                                          */
-  /* ------------------------------------------------------------- */
-
-  TH2D pixelThresholdMap(
-    "PixelThresholdMap",
-    "Pixel Threshold Map (keV);LV Strip;HV Strip",
-    64,0,64,
-    64,64,0);
-
-  TH2D pixelThresholdADCMap(
-    "PixelThresholdADCMap",
-    "Pixel Threshold Map (ADC);LV Strip;HV Strip",
-    64,0,64,
-    64,64,0);
-
-  /* force ROOT to display full strip axes */
-
-  pixelThresholdMap.GetXaxis()->SetNdivisions(64,false);
-  pixelThresholdMap.GetYaxis()->SetNdivisions(64,false);
-
-  pixelThresholdADCMap.GetXaxis()->SetNdivisions(64,false);
-  pixelThresholdADCMap.GetYaxis()->SetNdivisions(64,false);
-
-
-  for(int lv=0;lv<64;lv++)
-  {
-    if(thresholdLV.find(lv)==thresholdLV.end()) continue;
-
-    for(int hv=0;hv<64;hv++)
-    {
-      if(thresholdHV.find(hv)==thresholdHV.end()) continue;
-
-      double pixelThr=max(thresholdLV[lv],thresholdHV[hv]);
-      pixelThresholdMap.Fill(lv,hv,pixelThr);
 
-      double pixelADC=max(thresholdLV_ADC[lv],thresholdHV_ADC[hv]);
-      pixelThresholdADCMap.Fill(lv,hv,pixelADC);
-    }
-  }
 
   
   /* ------------------------------------------------------------- */
@@ -1135,20 +1348,20 @@ int main(int argc,char** argv)
   /* ------------------------------------------------------------- */
 
   // --- FAST CSV ---
-  ofstream csv_TAC_HV(outfile + "_Fast_HV_thresholds.csv");
-  ofstream csv_TAC_LV(outfile + "_Fast_LV_thresholds.csv");
+  ofstream csv_TAC_HV(m_OutputPrefix + "_Fast_HV_thresholds.csv");
+  ofstream csv_TAC_LV(m_OutputPrefix + "_Fast_LV_thresholds.csv");
 
   csv_TAC_HV << "detector_side,strip,threshold_adc,threshold_keV\n";
   csv_TAC_LV << "detector_side,strip,threshold_adc,threshold_keV\n";
 
-  cout << "Writing FAST CSV entries: " << thresholds_TAC.size() << endl;
+  cout << "Writing FAST CSV entries: " << m_FastThresholds.size() << endl;
   
-  for(const auto& kv : thresholds_TAC)
+  for(const auto& kv : m_FastThresholds)
   {
     char side = kv.first.side;
     int strip = kv.first.strip;
 
-    double thr_adc = thresholds_TAC_ADC[kv.first];
+    double thr_adc = m_FastThresholdsADC.at(kv.first);
     double thr_keV = kv.second;
 
     if(side == 'h')
@@ -1160,25 +1373,31 @@ int main(int argc,char** argv)
       csv_TAC_LV << "l," << strip << "," << thr_adc << "," << thr_keV << "\n";
     }
   }
-
+  
+  
+  csv_HV.close();
+  csv_LV.close();
   csv_TAC_HV.close();
   csv_TAC_LV.close();
+}
+
+
+void MStripThresholdFinder::WriteDiagnostics() const
+{
   
-  
+  if (m_SlowThresholds.empty() && m_FastThresholds.empty())
+  {
+    cout << "Warning: No thresholds available for diagnostics." << endl;
+  }
   
   /* ------------------------------------------------------------- */
   /* ROOT output                                                   */
   /* ------------------------------------------------------------- */
-  //cout << "DEBUG: outfile being used = " << outfile << endl;
-  TFile f((outfile+"_diagnostics.root").c_str(),"RECREATE");
+  //cout << "DEBUG: m_OutputPrefix being used = " << m_OutputPrefix << endl;
+  TFile f((m_OutputPrefix + "_diagnostics.root").Data(), "RECREATE");
   
 
 
-  /* ------------------------------------------------------------- */
-  /*  Slow and Fast Threshold diagnostic plots                     */
-  /* ------------------------------------------------------------- */
- 
-
   // -------------------------------------------------------------
   // SLOW threshold per strip (HV vs LV scatter)
   // -------------------------------------------------------------
@@ -1201,7 +1420,7 @@ int main(int argc,char** argv)
   gSlowThresh_HV->SetMarkerColor(kRed);
 
   // Fill graphs
-  for(const auto& kv : thresholds)
+  for(const auto& kv : m_SlowThresholds)
   {
     int strip = kv.first.strip;
     char side = kv.first.side;
@@ -1226,7 +1445,7 @@ int main(int argc,char** argv)
 
   // Optional: auto-scale Y axis
   double ymin = 1e9, ymax = -1e9;
-  for(const auto& kv : thresholds)
+  for(const auto& kv : m_SlowThresholds)
   {
     if(kv.first.strip == 64) continue;
     double v = kv.second;
@@ -1282,7 +1501,7 @@ int main(int argc,char** argv)
   hSlowDist_HV->SetLineWidth(2);
 
   // Fill histograms
-  for(const auto& kv : thresholds)
+  for(const auto& kv : m_SlowThresholds)
   {
     int strip = kv.first.strip;
     char side = kv.first.side;
@@ -1321,8 +1540,7 @@ int main(int argc,char** argv)
   hSlowDist_LV->Write();
   hSlowDist_HV->Write();
   
-  
-
+ 
 
   // -------------------------------------------------------------
   // FAST threshold per strip histogram
@@ -1333,7 +1551,7 @@ int main(int argc,char** argv)
     65, 0, 65
   );
 
-  for(const auto& kv : thresholds_TAC)
+  for(const auto& kv : m_FastThresholds)
   {
     int strip = kv.first.strip;
     double thr_keV = kv.second;
@@ -1344,145 +1562,171 @@ int main(int argc,char** argv)
   }
 
   hFastThreshPerStrip->Write();
-
-
-  
+ 
   
-  /* ------------------------------------------------------------- */
-  /* Threshold vs strip for HV and LV sides                        */
-  /* ------------------------------------------------------------- */
-
-  TGraph Threshold_vs_Strip_LV(
-    stripIndex_LV.size(),
-    stripIndex_LV.data(),
-    thresholdValues_LV.data());
-
-  Threshold_vs_Strip_LV.SetName("Threshold_vs_Strip_LV");
-  Threshold_vs_Strip_LV.SetTitle("Threshold vs Strip;Strip;Threshold (keV)");
-
-  Threshold_vs_Strip_LV.SetMarkerStyle(20);
-  Threshold_vs_Strip_LV.SetMarkerColor(kBlue);
-  Threshold_vs_Strip_LV.SetMarkerSize(1);
+  // ------------------------------------------------------------- 
+  // Threshold vs strip for HV and LV sides                        
+  // ------------------------------------------------------------- 
 
-  Threshold_vs_Strip_LV.Write();
-
-
-  TGraph Threshold_vs_Strip_HV(
-    stripIndex_HV.size(),
-    stripIndex_HV.data(),
-    thresholdValues_HV.data());
+  if (!m_stripIndex_LV.empty())
+  {
+    TGraph Threshold_vs_Strip_LV(
+      m_stripIndex_LV.size(),
+      m_stripIndex_LV.data(),
+      m_thresholdValues_LV.data());
 
-  Threshold_vs_Strip_HV.SetName("Threshold_vs_Strip_HV");
+    Threshold_vs_Strip_LV.SetName("Threshold_vs_Strip_LV");
+    Threshold_vs_Strip_LV.SetTitle("Threshold vs Strip (LV)");
+    Threshold_vs_Strip_LV.SetMarkerStyle(20);
+    Threshold_vs_Strip_LV.SetMarkerColor(kBlue);
 
-  Threshold_vs_Strip_HV.SetMarkerStyle(20);
-  Threshold_vs_Strip_HV.SetMarkerColor(kRed);
-  Threshold_vs_Strip_HV.SetMarkerSize(1);
+    Threshold_vs_Strip_LV.Write();
+  }
 
-  Threshold_vs_Strip_HV.Write();
+  if (!m_stripIndex_HV.empty())
+  {
+    TGraph Threshold_vs_Strip_HV(
+      m_stripIndex_HV.size(),
+      m_stripIndex_HV.data(),
+      m_thresholdValues_HV.data());
 
+    Threshold_vs_Strip_HV.SetName("Threshold_vs_Strip_HV");
+    Threshold_vs_Strip_HV.SetTitle("Threshold vs Strip (HV)");
+    Threshold_vs_Strip_HV.SetMarkerStyle(20);
+    Threshold_vs_Strip_HV.SetMarkerColor(kRed);
 
+    Threshold_vs_Strip_HV.Write();
+  }
 
-  /* ------------------------------------------------------------- */
-  /* Noise peak ADC vs strip for HV and LV sides                   */
-  /* ------------------------------------------------------------- */
 
-  TGraph NoisePeakADC_vs_Strip_LV(
-    stripIndex_LV.size(),
-    stripIndex_LV.data(),
-    noisePeakADC_LV.data());
+  
+  for (auto& kv : dt0_hists)
+  {
+    const StripKey& key = kv.first;
+
+    if (dt1_hists.find(key) == dt1_hists.end()) continue;
+  
+    TH1D* dt0 = kv.second;
+    TH1D* dt1 = dt1_hists.at(key);
+
+    int det = key.det;
+    char side = key.side;
+    int strip = key.strip;
+
+    // -------------------------------
+    // Create canvas
+    // -------------------------------
+    string cname = "cFast_" + to_string(det) + "_" + side + "_" + to_string(strip);
+    TCanvas* c = new TCanvas(cname.c_str(), cname.c_str(), 800, 600);
+
+    // -------------------------------
+    // Styling
+    // -------------------------------
+    dt0->SetLineColor(kBlack);
+    dt1->SetLineColor(kBlue);
+
+    dt0->SetTitle(Form(
+      "Fast Shaper Threshold (det=%d %c strip=%d);Energy (keV);Counts",
+      det, side, strip
+    ));
+	dt0->GetXaxis()->SetRangeUser(0, 100);
+	
+	
 
-  NoisePeakADC_vs_Strip_LV.SetName("NoisePeakADC_vs_Strip_LV");
-  NoisePeakADC_vs_Strip_LV.SetTitle("Noise Peak ADC vs Strip;Strip;Noise Peak (ADC)");
+    // -------------------------------
+    // Draw both
+    // -------------------------------
+    dt0->Draw("HIST");
+    dt1->Draw("HIST SAME");
+	
+	gPad->Update();
 
-  NoisePeakADC_vs_Strip_LV.SetMarkerStyle(20);
-  NoisePeakADC_vs_Strip_LV.SetMarkerColor(kBlue);
-  NoisePeakADC_vs_Strip_LV.SetMarkerSize(1);
 
-  NoisePeakADC_vs_Strip_LV.Write();
+    TLegend* leg = new TLegend(0.65,0.7,0.88,0.88);
+    leg->AddEntry(dt0, "dt0", "l");
+    leg->AddEntry(dt1, "dt1", "l");
 
+    // -------------------------------
+    // Threshold line (NOW IN keV)
+    // -------------------------------
+    if (m_FastThresholds.find(key) != m_FastThresholds.end())
+    { 
 
-  TGraph NoisePeakADC_vs_Strip_HV(
-    stripIndex_HV.size(),
-    stripIndex_HV.data(),
-    noisePeakADC_HV.data());
+      double thr_keV = m_FastThresholds.at(key);  
 
-  NoisePeakADC_vs_Strip_HV.SetName("NoisePeakADC_vs_Strip_HV");
+      double ymin = gPad->GetUymin();
+      double ymax = gPad->GetUymax();
 
-  NoisePeakADC_vs_Strip_HV.SetMarkerStyle(20);
-  NoisePeakADC_vs_Strip_HV.SetMarkerColor(kRed);
-  NoisePeakADC_vs_Strip_HV.SetMarkerSize(1);
+      TLine* line = new TLine(thr_keV, ymin, thr_keV, ymax);
+      line->SetLineColor(kRed);
+      line->SetLineWidth(2);
+      line->Draw("SAME");
 
-  NoisePeakADC_vs_Strip_HV.Write();
+      // Legend entry (fix from earlier)
+      leg->AddEntry(line, "Fast Threshold", "l");
+    }
 
- 
+    //leg->AddEntry((TObject*)0, "Fast Threshold", ""); // label only
+    leg->Draw();
 
+    // -------------------------------
+    // Save
+    // -------------------------------
+    c->Write();
+ }
   
-  /* ------------------------------------------------------------- */
-  /* TAC Threshold vs Strip                                        */
-  /* ------------------------------------------------------------- */
-
-  TGraph Threshold_TAC_vs_Strip_LV(
-    stripIndex_TAC_LV.size(),
-    stripIndex_TAC_LV.data(),
-    thresholdValues_TAC_LV.data());
-
-  Threshold_TAC_vs_Strip_LV.SetName("Threshold_TAC_vs_Strip_LV");
-  Threshold_TAC_vs_Strip_LV.SetTitle("TAC Threshold vs Strip;Strip;Threshold (keV)");
-  Threshold_TAC_vs_Strip_LV.SetMarkerStyle(20);
-  Threshold_TAC_vs_Strip_LV.SetMarkerColor(kBlue);
-  Threshold_TAC_vs_Strip_LV.SetMarkerSize(1);
-
-  Threshold_TAC_vs_Strip_LV.Write();
-
-
-  TGraph Threshold_TAC_vs_Strip_HV(
-    stripIndex_TAC_HV.size(),
-    stripIndex_TAC_HV.data(),
-    thresholdValues_TAC_HV.data());
-
-  Threshold_TAC_vs_Strip_HV.SetName("Threshold_TAC_vs_Strip_HV");
-  Threshold_TAC_vs_Strip_HV.SetMarkerStyle(20);
-  Threshold_TAC_vs_Strip_HV.SetMarkerColor(kRed);
-  Threshold_TAC_vs_Strip_HV.SetMarkerSize(1);
 
-  Threshold_TAC_vs_Strip_HV.Write();
-  
-  
-  
   
+
   
   /* ------------------------------------------------------------- */
   /* Write ADC spectra and create energy spectra with thresholds   */
   /* ------------------------------------------------------------- */
 
-  for(auto& kv:histograms)
+  for(auto& kv:m_ADCHistograms)
   {
     StripKey key=kv.first;
     TH1D* adcHist=kv.second;
 
     adcHist->Write();
-
-    string name="Energy_"+to_string(key.det)+"_"+key.side+"_"+to_string(key.strip);
+    
+	int det = key.det;
+    char side = key.side;
+    int strip = key.strip;
+	
+	
+    //string name="Slow Threshold Det "+to_string(key.det)+", Side"+key.side+", Strip"+to_string(key.strip);
+    string name = "Energy_" + to_string(det) + "_" + side + "_" + to_string(strip);
+	
+	double maxE = m_EnergyCal.ADCToEnergy(det, side, strip, m_HistogramMaxADC);
+	
 
     TH1D* energyHist=new TH1D(
         name.c_str(),
         name.c_str(),
         adcHist->GetNbinsX(),
         0,
-        helperCal.ADCToEnergy(key.det,key.side,key.strip,histogramMaxADC)
+        maxE
     );
-
+    
+	energyHist->SetTitle(Form(
+      "Slow Threshold (det=%d side=%c strip=%d);Energy (keV);Counts",
+      det, side, strip
+    ));
+	
+	energyHist->GetXaxis()->SetRangeUser(0, 100);
+	
     for(int b=1;b<=adcHist->GetNbinsX();b++)
     {
       double adc=adcHist->GetBinCenter(b);
-      double energy=helperCal.ADCToEnergy(key.det,key.side,key.strip,adc);
+      double energy=m_EnergyCal.ADCToEnergy(key.det,key.side,key.strip,adc);
       double counts=adcHist->GetBinContent(b);
 
       int ebin=energyHist->FindBin(energy);
       energyHist->AddBinContent(ebin,counts);
     }
 
-    double thr=thresholds[key];
+    double thr = m_SlowThresholds.at(key);
 
     TLine* line=new TLine(thr,0,thr,energyHist->GetMaximum());
     line->SetLineColor(kRed);
@@ -1517,7 +1761,7 @@ int main(int argc,char** argv)
   hFastDist_HV->SetLineWidth(2);
 
   // Fill histograms
-  for(const auto& kv : thresholds_TAC)
+  for(const auto& kv : m_FastThresholds)
   {
     int strip = kv.first.strip;
     char side = kv.first.side;
@@ -1565,7 +1809,7 @@ int main(int argc,char** argv)
     200, 0, 2000
   );
 
-  for(const auto& kv : thresholds_TAC_ADC)
+  for(const auto& kv : m_FastThresholdsADC)
   {
     FastThresholdDistribution_ADC->Fill(kv.second);
   }
@@ -1595,7 +1839,7 @@ int main(int argc,char** argv)
   gFastThresh_HV->SetMarkerColor(kRed);
 
   // Fill graphs
-  for(const auto& kv : thresholds_TAC)
+  for(const auto& kv : m_FastThresholds)
   {
     int strip = kv.first.strip;
     char side = kv.first.side;
@@ -1652,111 +1896,6 @@ int main(int argc,char** argv)
   gFastThresh_HV->Write();
   
   
-  /* ------------------------------------------------------------- */
-  /* Build Slow vs TAC comparison                                  */
-  /* ------------------------------------------------------------- */
-
-  for(const auto& kv : thresholds)
-  {
-    StripKey key = kv.first;
-
-    if(thresholds_TAC.find(key) == thresholds_TAC.end())
-      continue;
-
-    double slowE = kv.second;
-    double tacE  = thresholds_TAC[key];
-
-    if(slowE > 0 && tacE > 0)
-    {
-      slowEnergyVec.push_back(slowE);
-      tacEnergyVec.push_back(tacE);
-    }
-  }
-
-  TGraph Slow_vs_TAC(
-    slowEnergyVec.size(),
-    slowEnergyVec.data(),
-    tacEnergyVec.data());
-
-  Slow_vs_TAC.SetName("Slow_vs_TAC");
-  Slow_vs_TAC.SetTitle("Slow vs TAC Energy;Slow Energy (keV);TAC Energy (keV)");
-  Slow_vs_TAC.SetMarkerStyle(20);
-  Slow_vs_TAC.SetMarkerSize(1);
-
-  Slow_vs_TAC.Write();
-  
-  
-  /* ------------------------------------------------------------- */
-  /* dt0 vs dt1 diagnostic histogram                               */
-  /* ------------------------------------------------------------- */
-
-  
-  
-  for(auto& kv : timingCounts)
-  {
-    StripKey key = kv.first;
-    auto& adcMap = kv.second;
-
-    if(key.strip == 64)
-    {
-      continue;
-    }
-
-    string name0 = "dt0_" + to_string(key.det) + "_" + key.side + "_" + to_string(key.strip);
-    string name1 = "dt1_" + to_string(key.det) + "_" + key.side + "_" + to_string(key.strip);
-
-    TH1D* h0 = new TH1D(name0.c_str(), name0.c_str(), 500, 0, 100);
-    TH1D* h1 = new TH1D(name1.c_str(), name1.c_str(), 500, 0, 100);
-
-    for(auto& a : adcMap)
-    {
-      int adc = a.first;
-      int n0  = a.second.first;
-      int n1  = a.second.second;
-
-      //double energy = calib[key.det][key.side][key.strip].Evaluate(adc);
-      double energy = helperCal.ADCToEnergy(key.det, key.side, key.strip, adc);
-	  
-	  //h0->Fill(energy, n0);
-      double e0 = helperCal.ADCToEnergy(key.det, key.side, key.strip, adc);
-      double e1 = helperCal.ADCToEnergy(key.det, key.side, key.strip, adc + 1);
-
-      // distribute counts across the interval
-      int nSub = 5;  // small subdivision
-      for(int i = 0; i < nSub; ++i)
-      {
-        double e = e0 + (e1 - e0)*(i + 0.5)/nSub;
-        h0->Fill(e, n0 / (double)nSub);
-        h1->Fill(e, n1 / (double)nSub);
-      }
-	  
-	 // h1->Fill(energy, n1);
-    }
-
-    h0->SetLineColor(kRed);
-    h1->SetLineColor(kBlue);
-
-    // --- FAST threshold line (energy space) ---
-    if(thresholds_TAC_ADC.find(key) != thresholds_TAC_ADC.end())
-    {
-      double thr_adc = thresholds_TAC_ADC[key];
-      //double thr_keV = calib[key.det][key.side][key.strip].Evaluate(thr_adc);
-      double thr_keV = helperCal.ADCToEnergy(key.det, key.side, key.strip, thr_adc);
-	  
-      double maxY = max(h0->GetMaximum(), h1->GetMaximum());
-
-      TLine* line = new TLine(thr_keV, 0, thr_keV, maxY);
-      line->SetLineColor(kGreen+2);
-      line->SetLineWidth(2);
-      line->SetLineStyle(2); // optional (dashed)
-
-      h0->GetListOfFunctions()->Add(line);
-    }
-
-    h0->Write();
-    h1->Write();
-  }
-  
   // -------------------------------------------------------------
   // SLOW threshold pixel map (LV vs HV)
   // -------------------------------------------------------------
@@ -1771,8 +1910,8 @@ int main(int argc,char** argv)
   map<int,double> slowLV;
   map<int,double> slowHV;
 
-  // Separate thresholds by side
-  for(const auto& kv : thresholds)
+  // Separate m_SlowThresholds by side
+  for(const auto& kv : m_SlowThresholds)
   {
     int strip = kv.first.strip;
     char side = kv.first.side;
@@ -1824,69 +1963,83 @@ int main(int argc,char** argv)
   cSlowPixel->Write();
   hSlowPixelMap->Write();
   
+
+ 
+  //------------------------------------------------------------
+  // New Plots
+  //------------------------------------------------------------
   
   
+  // Plot Slow Thresholds per Strip
   
-  
+  TGraph* gSlowLV = new TGraph();
+  TGraph* gSlowHV = new TGraph();
 
-  f.Close();
-  /* ------------------------------------------------------------- */
-  /* Helpful ROOT instructions                                     */
-  /* ------------------------------------------------------------- */
+  for (const auto& kv : m_SlowThresholds)
+  {
+    const StripKey& key = kv.first;
+    double thr = kv.second;
 
-  cout<<endl;
-  cout<<"Diagnostics written to "<<outfile<<"_diagnostics.root"<<endl;
-  cout<<endl;
+    if (key.strip == 64) continue; // skip guard ring if needed
 
-  cout<<"Example ROOT commands for diagnostics:"<<endl;
-  cout<<"---------------------------------------"<<endl;
+    if (key.side == 'l')
+    {
+      gSlowLV->SetPoint(gSlowLV->GetN(), key.strip, thr);
+    }
+    else if (key.side == 'h')
+    {
+      gSlowHV->SetPoint(gSlowHV->GetN(), key.strip, thr);
+    }
+  }
 
-  cout<<"Open file:"<<endl;
-  cout<<"  root -l "<<outfile<<"_diagnostics.root"<<endl;
-  cout<<endl;
+  // Style (reuse your preferences here)
+  gSlowLV->SetTitle("Slow Threshold vs Strip (LV);Strip;Threshold [keV]");
+  gSlowHV->SetTitle("Slow Threshold vs Strip (HV);Strip;Threshold [keV]");
 
-  cout<<"Slow threshold diagnostic plots:"<<endl;
-  cout<<"---------------------------------------"<<endl;
+  TCanvas* cSlowStrip = new TCanvas("cSlowStrip","Slow Threshold vs Strip",1200,500);
+  cSlowStrip->Divide(2,1);
 
-  cout<<"Slow threshold distribution:"<<endl;
-  cout<<"  cSlowDist->Draw()"<<endl;
-  cout<<endl;
+  cSlowStrip->cd(1);
+  gSlowLV->Draw("AP");
 
-  cout<<endl;
-  cout<<"Slow threshold vs strip:"<<endl;
-  cout<<"  cSlowThresh->Draw()"<<endl;
-  cout<<endl;
-  
-  cout<<"Example energy spectrum with threshold:"<<endl;
-  cout<<"  Energy_0_h_10->Draw()"<<endl;
-  cout<<"  Energy_0_h_10->GetXaxis()->SetRangeUser(0,30)"<<endl;
-  cout<<endl;
+  cSlowStrip->cd(2);
+  gSlowHV->Draw("AP");
 
-  cout<<"Pixel threshold heat maps:"<<endl;
-  cout<<"  cSlowPixel->Draw()"<<endl;
-  cout<<endl;
+  cSlowStrip->Write();
   
+  // PLot Fast Thresholds per strip
   
-  
-  cout<<endl;
-  cout<<"FAST threshold diagnostics:"<<endl;
-  cout<<"---------------------------------------"<<endl;
+  TGraph* gFastLV = new TGraph();
+  TGraph* gFastHV = new TGraph();
 
-  cout<<"Fast threshold distribution (keV):"<<endl;
-  cout<<"  cFastDist->Draw()"<<endl;
-  cout<<endl;
+  for (const auto& kv : m_FastThresholds)
+  {
+    const StripKey& key = kv.first;
+    double thr = kv.second;
 
-  cout<<"HV and LV FAST thresholds:"<<endl;
-  cout<<"  cFastThresh->Draw()"<<endl;
-  cout<<endl;
-  
-  cout<<"Fast threshold diagnostic; single channel (dt0 vs dt1):"<<endl;
-  cout<<"  dt0_0_l_10->Draw()"<<endl;
-  cout<<"  dt1_0_l_10->SetLineColor(kBlue)"<<endl;
-  cout<<"  dt1_0_l_10->Draw(\"SAME\")"<<endl;
-  cout<<endl;
-  
-  
-  return 0;
+    if (key.strip == 64) continue;
+
+    if (key.side == 'l')
+    {
+      gFastLV->SetPoint(gFastLV->GetN(), key.strip, thr);
+    }
+    else if (key.side == 'h')
+    {
+      gFastHV->SetPoint(gFastHV->GetN(), key.strip, thr);
+    }
+  }
+
+  TCanvas* cFastStrip = new TCanvas("cFastStrip","Fast Threshold vs Strip",1200,500);
+  cFastStrip->Divide(2,1);
+
+  cFastStrip->cd(1);
+  gFastLV->Draw("AP");
+
+  cFastStrip->cd(2);
+  gFastHV->Draw("AP");
+
+  cFastStrip->Write();
+
+  f.Close();
 }