AliceO2Group · maciacco · Jul 22, 2026 · Jul 22, 2026 · Jul 22, 2026 · Jul 22, 2026
@@ -27,6 +27,8 @@ struct DPLDigitizerParam : public o2::conf::ConfigurableParamHelper<DPLDigitizer
   float noisePerPixel = DEFNoisePerPixel(); ///< ALPIDE Noise per channel
 
   double timeOffset = 0.;                 ///< time offset (in seconds!) to calculate ROFrame from hit time
+  float timeResolution = 0.020f;          ///< time resolution sigma in ns (20 ps default)
+  float efficiency = 0.98f;               ///< detection efficiency
   int chargeThreshold = 0;                ///< charge threshold in Nelectrons
   int minChargeToAccount = 7;             ///< minimum charge contribution to account
   int nSimSteps = 1;                      ///< number of steps in response simulation

@@ -74,17 +74,6 @@ class Digitizer : public TObject
   // Provide the common iotof::GeometryTGeo to access matrices and segmentation
   void setGeometry(const o2::iotof::GeometryTGeo* gm) { mGeometry = gm; }
 
-  // Setters for digitization parameters
-  void setChargeThreshold(float thr) { mChargeThreshold = thr; }
-  void setTimeResolution(float res) { mTimeResolution = res; }
-  void setEfficiency(float eff) { mEfficiency = eff; }
-  void setEnergyToCharge(float e2c) { mEnergyToCharge = e2c; }
-
-  // Getters
-  float getChargeThreshold() const { return mChargeThreshold; }
-  float getTimeResolution() const { return mTimeResolution; }
-  float getEfficiency() const { return mEfficiency; }
-
  private:
   /// Process a single hit
   void processHit(const o2::itsmft::Hit& hit, int evID, int srcID);
@@ -133,12 +122,6 @@ class Digitizer : public TObject
   o2::InteractionRecord mROFRecordIR;   ///< interaction record assigned to the output ROF
   bool mContinuous = true;              ///< continuous readout mode
 
-  // Digitization parameters
-  float mChargeThreshold = 100.f;  ///< charge threshold for digit creation (electrons)
-  float mTimeResolution = 0.020f;  ///< time resolution sigma in ns (20 ps default)
-  float mEfficiency = 0.98f;       ///< detection efficiency
-  float mEnergyToCharge = 3.6e-9f; ///< energy loss to electrons conversion (3.6 eV per e-h pair in Si)
-
   static o2::iotof::Segmentation* sSegmentation; ///< IOTOF segmentation instance (singleton)
 
   ClassDefNV(Digitizer, 1);

@@ -50,10 +50,12 @@ void Digitizer::init()
     /// }
   }
 
+  const auto& digitizerParams = o2::iotof::DPLDigitizerParam::Instance();
+
   LOG(info) << "Initializing IOTOF digitizer";
-  LOG(info) << "  Time resolution: " << mTimeResolution * 1e3 << " ps";
-  LOG(info) << "  Charge threshold: " << mChargeThreshold << " electrons";
-  LOG(info) << "  Detection efficiency: " << mEfficiency * 100 << " %";
+  LOG(info) << "  Time resolution: " << digitizerParams.timeResolution * 1e3 << " ps";
+  LOG(info) << "  Charge threshold: " << digitizerParams.chargeThreshold << " electrons";
+  LOG(info) << "  Detection efficiency: " << digitizerParams.efficiency * 100 << " %";
   LOG(info) << "  Continuous mode: " << (mContinuous ? "ON" : "OFF");
   sSegmentation = o2::iotof::Segmentation::Instance();
 }
@@ -114,8 +116,8 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, int evID, int srcID)
   int electronsPerStep = static_cast<int>(charge / digitizerParams.nSimSteps);
 
   // Apply charge threshold
-  if (charge < mChargeThreshold) {
-    LOG(debug) << "Hit rejected by charge threshold: " << charge << " < " << mChargeThreshold;
+  if (charge < digitizerParams.chargeThreshold) {
+    LOG(debug) << "Hit rejected by charge threshold: " << charge << " < " << digitizerParams.chargeThreshold;
     return;
   }
 
@@ -256,8 +258,9 @@ void Digitizer::stepping(const o2::itsmft::Hit& hit, float**& respMatrix, int& r
 double Digitizer::smearTime(double time) const
 {
   // Apply Gaussian smearing to simulate detector time resolution
-  if (mTimeResolution > 0) {
-    return time + gRandom->Gaus(0, mTimeResolution);
+  const auto& digitizerParams = o2::iotof::DPLDigitizerParam::Instance();
+  if (digitizerParams.timeResolution > 0) {
+    return time + gRandom->Gaus(0, digitizerParams.timeResolution);
   }
   return time;
 }
@@ -267,15 +270,17 @@ int Digitizer::energyToCharge(float energyLoss) const
 {
   // Convert energy loss (GeV) to number of electrons
   // Typical value: 3.6 eV per electron-hole pair in silicon
-  // energyLoss is in GeV, mEnergyToCharge is GeV per electron
-  return static_cast<int>(energyLoss / mEnergyToCharge);
+  // energyLoss is in GeV, energyToNElectrons is electrons per GeV
+  const auto& digitizerParams = o2::iotof::DPLDigitizerParam::Instance();
+  return static_cast<int>(energyLoss * digitizerParams.energyToNElectrons);
 }
 
 //_______________________________________________________________________
 bool Digitizer::isEfficient() const
 {
   // Apply efficiency cut using random number
-  return gRandom->Uniform() < mEfficiency;
+  const auto& digitizerParams = o2::iotof::DPLDigitizerParam::Instance();
+  return gRandom->Uniform() < digitizerParams.efficiency;
 }
 
 //_______________________________________________________________________
@@ -284,6 +289,8 @@ void Digitizer::fillOutputContainer()
   LOG(info) << "Filling output container with digits from chips";
   LOG(debug) << "Number of chips: " << mChips.size();
 
+  const auto& digitizerParams = o2::iotof::DPLDigitizerParam::Instance();
+
   o2::itsmft::ROFRecord rof;
   rof.setFirstEntry(mDigits->size()); // index of the first digit
 
@@ -303,7 +310,7 @@ void Digitizer::fillOutputContainer()
     auto& chipDigits = chip.getDigits();
     for (const auto& [key, digit] : chipDigits) {
 
-      if (digit.getCharge() < mChargeThreshold) {
+      if (digit.getCharge() < digitizerParams.chargeThreshold) {
         continue; // skip digits below threshold
       }
 

@@ -59,7 +59,6 @@ class IOTOFDPLDigitizerTask : o2::base::BaseDPLDigitizer
     geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G)); // make sure L2G matrices are loaded
 
     mDigitizer.setGeometry(geom);
-    mDigitizer.setChargeThreshold(-1000.f);
     mDigitizer.init();
   }