change resolution computation at digit level, add relative information from resolution map

Author: GiorgioAlbertoLucia

Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/DPLDigitizerParam.h

@@ -30,10 +30,18 @@ struct DPLDigitizerParam : public o2::conf::ConfigurableParamHelper<DPLDigitizer
   float timeResolution = 0.020f;          ///< time resolution sigma in ns (20 ps default)
   float tdcBin = 0.010f;                  ///< TDC time bin (10 ps default)
   float efficiency = 0.98f;               ///< detection efficiency
+  
   std::string efficiencyFilePath{};       ///< optional efficiency map file path.
                                           ///< The efficiency map is currently available at /alice/cern.ch/user/g/glucia/ALICE3/IOTOF/pixelEfficiency/PixelEfficiencyMap_TH2.root. FIXME to be removed once switch to CCDBFetcher
   std::string efficiencyCcdbPath{};       ///< optional efficiency map CCDB path.
                                           ///< The efficiency map is currently available at Users/g/glucia/tmp/ALICE3/IOTOF/pixelEfficiency
+  std::string resolutionFilePath{};       ///< optional resolution map file path.
+                                          ///< The resolution map is currently available at /alice/cern.ch/user/g/glucia/ALICE3/IOTOF/pixelEfficiency/PixelResolutionMap_TH2.root. FIXME to be removed once switch to CCDBFetcher
+  std::string resolutionCcdbPath{};       ///< optional resolution map CCDB path.
+  std::string timeOfArrivalFilePath{};    ///< optional time of arrival map file path.
+                                          ///< The time of arrival map is currently available at /alice/cern.ch/user/g
+  std::string timeOfArrivalCcdbPath{};    ///< optional time of arrival map CCDB path.
+
   int chargeThreshold = 100;              ///< charge threshold in Nelectrons
   int minChargeToAccount = 7;             ///< minimum charge contribution to account
   int nSimSteps = 10;                     ///< number of steps in response simulation

Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Digitizer.cxx

@@ -73,6 +73,26 @@ void Digitizer::init()
     LOG(info) << "No efficiency map provided, using uniform efficiency: " << digitizerParams.efficiency * 100 << " %";
   }
 
+  if (!digitizerParams.resolutionCcdbPath.empty()) {
+    LOG(info) << "Loading resolution map from CCDB: " << digitizerParams.resolutionCcdbPath;
+    loadMapFromCCDB(mResolutionMap, digitizerParams.resolutionCcdbPath);
+  } else if (!digitizerParams.resolutionFilePath.empty()) {
+    LOG(info) << "Loading resolution map from file: " << digitizerParams.resolutionFilePath;
+    loadMap(mResolutionMap, digitizerParams.resolutionFilePath, "hResolutionMap");
+  } else {
+    LOG(info) << "No resolution map provided, using uniform time resolution: " << digitizerParams.timeResolution * 1e3 << " ps";
+  }
+
+  if (!digitizerParams.timeOfArrivalCcdbPath.empty()) {
+    LOG(info) << "Loading time of arrival map from CCDB: " << digitizerParams.timeOfArrivalCcdbPath;
+    loadMapFromCCDB(mTimeOfArrivalMap, digitizerParams.timeOfArrivalCcdbPath);
+  } else if (!digitizerParams.timeOfArrivalFilePath.empty()) {
+    LOG(info) << "Loading time of arrival map from file: " << digitizerParams.timeOfArrivalFilePath;
+    loadMap(mTimeOfArrivalMap, digitizerParams.timeOfArrivalFilePath, "hTimeOfArrivalMap");
+  } else {
+    LOG(info) << "No time of arrival map provided";
+  }
+
   sSegmentation = o2::iotof::Segmentation::Instance();
 }
 
@@ -171,6 +191,7 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, int evID, int srcID)
         LOG(debug) << "Hit rejected by efficiency cut at pixel (row,col) = (" << rowIS << ", " << colIS << ")";
         continue;
       }
+      double smearedTime = smearTime(hitTimeWrtBC, avgHitLocalX[irow][icol], avgHitLocalZ[irow][icol]);
 
       const int nElectronsSampled = gRandom->Poisson(electronsPerStep * nEleResp);
       // Noise can be added here if needed
@@ -324,12 +345,22 @@ void Digitizer::stepping(const o2::itsmft::Hit& hit, float**& respMatrix, float*
 }
 
 //_______________________________________________________________________
-double Digitizer::smearTime(double time) const
+double Digitizer::smearTime(double time, const float x, const float y) const
 {
   // Apply Gaussian smearing to simulate detector time resolution
   const auto& digitizerParams = o2::iotof::DPLDigitizerParam::Instance();
+  
+  float resolutionScaling = 1.;
+  if (mResolutionMap) {
+    const float minimumResolution = mResolutionMap->GetMinimum();
+    int bin = mResolutionMap->FindBin(x * o2::iotof::Digitizer::cm2um, y * o2::iotof::Digitizer::cm2um);
+    resolutionScaling = mResolutionMap->GetBinContent(bin) / minimumResolution;
+    LOG(debug) << "Time resolution map check: x=" << x * o2::iotof::Digitizer::cm2um << ", y=" << y * o2::iotof::Digitizer::cm2um << ", bin=" << bin << ", resolution=" << minimumResolution;
+    LOG(debug) << "Time resolution scaling: " << resolutionScaling;
+  }
+
   if (digitizerParams.timeResolution > 0) {
-    return time + gRandom->Gaus(0, digitizerParams.timeResolution);
+    return time + gRandom->Gaus(0, digitizerParams.timeResolution * resolutionScaling);
   }
   return time;
 }