@@ -30,8 +30,16 @@ 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
+  
+  // Optional map paths. Prefix with "ccdb://" to fetch from CCDB, otherwise the path is opened with TFile::Open
+  // (local file, alien://, root://, ...). An empty path disables the map.
+  std::string efficiencyMapPath{};        ///< optional efficiency map path.
+                                          ///< e.g. ccdb://Users/g/glucia/tmp/ALICE3/IOTOF/pixelEfficiency
+                                          ///< or alien:///alice/cern.ch/user/g/glucia/ALICE3/IOTOF/pixelEfficiency/PixelEfficiencyMap_TH2.root
+  std::string resolutionMapPath{};        ///< optional resolution map path.
+                                          ///< e.g. alien:///alice/cern.ch/user/g/glucia/ALICE3/IOTOF/pixelEfficiency/PixelResolutionMap_TH2.root
+  std::string timeOfArrivalMapPath{};     ///< optional time of arrival map 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
 
@@ -86,13 +86,14 @@ class Digitizer : public TObject
   void stepping(const o2::itsmft::Hit& hit, float**& respMatrix, float**& avgHitLocalX, float**& avgHitLocalZ, int& rowStart, int& colStart, int& rowSpan, int& colSpan);
 
   /// Apply time smearing to simulate detector resolution
-  double smearTime(double time) const;
+  double smearTime(double time, const float x, const float z) const;
 
   /// Convert energy loss to charge
   int energyToCharge(float energyLoss) const;
 
-  /// Load the efficiency map from a file
-  void loadEfficiencyMap(const std::string& filePath);
+  /// Load a map from CCDB (path prefixed with "ccdb://") or from a ROOT file (any other path)
+  /// \param mapName Name of the histogram inside the ROOT file (ignored for CCDB)
+  void loadMap(TH2D*& map, const std::string& path, const char* mapName);
 
   /// Check if the hit passes efficiency cut
   /// \param x Detector local coordinate x in cm with respect to the center of the sensitive volume.
@@ -118,6 +119,8 @@ class Digitizer : public TObject
 
   const o2::iotof::GeometryTGeo* mGeometry = nullptr; ///< IOTOF geometry
   TH2D* mEfficiencyMap = nullptr;                     ///< Efficiency map for the detector
+  TH2D* mResolutionMap = nullptr;                     ///< Resolution map for the detector
+  TH2D* mTimeOfArrivalMap = nullptr;                  ///< Time of arrival map for the detector
 
   std::vector<o2::iotof::Chip> mChips;                                               //! Chips in the detector, indexed by chip ID
   std::deque<std::unique_ptr<std::vector<o2::iotof::McLabelRef>>> mExtraLabelBuffer; //! buffer for multiple mc labels to the same pixel
 
@@ -19,13 +19,15 @@
 #include "IOTOFSimulation/Digitizer.h"
 #include "IOTOFSimulation/DPLDigitizerParam.h"
 #include "DetectorsRaw/HBFUtils.h"
+#include "CCDB/BasicCCDBManager.h"
 
 #include <TCollection.h>
 #include <TFile.h>
 #include <TKey.h>
 #include <TRandom.h>
 
 #include <set>
+#include <string_view>
 #include <vector>
 #include <iostream>
 #include <numeric>
@@ -66,15 +68,28 @@ void Digitizer::init()
     }
   }
 
-  if (!digitizerParams.efficiencyFilePath.empty()) {
-    loadEfficiencyMap(digitizerParams.efficiencyFilePath);
-  }
+  const auto& digitizerParams = o2::iotof::DPLDigitizerParam::Instance();
 
   LOG(info) << "Initializing IOTOF digitizer";
   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");
+
+  loadMap(mEfficiencyMap, digitizerParams.efficiencyMapPath, "hEfficiencyMap");
+  if (!mEfficiencyMap) {
+    LOG(info) << "No efficiency map loaded, using uniform efficiency: " << digitizerParams.efficiency * 100 << " %";
+  }
+
+  loadMap(mResolutionMap, digitizerParams.resolutionMapPath, "hResolutionMap");
+  if (!mResolutionMap) {
+    LOG(info) << "No resolution map loaded, using uniform time resolution: " << digitizerParams.timeResolution * 1e3 << " ps";
+  }
+
+  loadMap(mTimeOfArrivalMap, digitizerParams.timeOfArrivalMapPath, "hTimeOfArrivalMap");
+  if (!mTimeOfArrivalMap) {
+    LOG(info) << "No time of arrival map loaded";
+  }
+
   sSegmentation = o2::iotof::Segmentation::Instance();
 }
 
@@ -173,12 +188,11 @@ 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
 
-      double smearedTime = smearTime(hitTimeWrtBC);
-
       registerDigits(chip, roFrameAbs, smearedTime, nROF,
                      static_cast<uint16_t>(rowIS), static_cast<uint16_t>(colIS), nElectronsSampled, label);
     }
@@ -326,12 +340,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 = minimumResolution > 0. ? mResolutionMap->GetBinContent(bin) / minimumResolution : 1.;
+    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;
 }
@@ -347,31 +371,59 @@ int Digitizer::energyToCharge(float energyLoss) const
 }
 
 //_______________________________________________________________________
-void Digitizer::loadEfficiencyMap(const std::string& filePath)
+
+void Digitizer::loadMap(TH2D*& map, const std::string& path, const char* mapName)
 {
-  // Load the efficiency map from a file
-  TFile* file = TFile::Open(filePath.c_str());
-  if (!file || !file->IsOpen()) {
-    LOG(error) << "Failed to open efficiency map file: " << filePath;
+  // Load a map either from CCDB (path prefixed with "ccdb://") or from a ROOT file
+  // (anything TFile::Open understands: local path, alien://, root://, http://, ...)
+  static constexpr std::string_view ccdbPrefix = "ccdb://";
+
+  if (path.empty()) {
     return;
   }
 
-  auto* rawMap = dynamic_cast<TH2D*>(file->Get("hEfficiencyMap"));
-  if (!rawMap) {
-    LOG(error) << "Failed to retrieve efficiency map from file: " << filePath;
-    LOG(error) << "Available keys in the file:";
-    TIter next(file->GetListOfKeys());
-    TKey* key;
-    while ((key = dynamic_cast<TKey*>(next()))) {
-      LOG(error) << "  " << key->GetName() << " (" << key->GetClassName() << ")";
+  TH2D* rawMap = nullptr;
+  TFile* file = nullptr;
+
+  if (path.rfind(ccdbPrefix, 0) == 0) {
+    const std::string ccdbPath = path.substr(ccdbPrefix.size());
+    LOG(info) << "Loading " << mapName << " from CCDB: " << ccdbPath;
+    rawMap = o2::ccdb::BasicCCDBManager::instance().get<TH2D>(ccdbPath); // owned by the CCDB manager
+    if (!rawMap) {
+      LOG(error) << "Failed to retrieve " << mapName << " from CCDB path: " << ccdbPath;
+      return;
+    }
+  } else {
+    LOG(info) << "Loading " << mapName << " from file: " << path;
+    file = TFile::Open(path.c_str());
+    if (!file || !file->IsOpen()) {
+      LOG(error) << "Failed to open file: " << path;
+      delete file;
+      return;
+    }
+    rawMap = dynamic_cast<TH2D*>(file->Get(mapName));
+    if (!rawMap) {
+      LOG(error) << "Failed to retrieve " << mapName << " from file: " << path;
+      LOG(error) << "Available keys in the file:";
+      TIter next(file->GetListOfKeys());
+      TKey* key;
+      while ((key = dynamic_cast<TKey*>(next()))) {
+        LOG(error) << "  " << key->GetName() << " (" << key->GetClassName() << ")";
+      }
+      file->Close();
+      delete file;
+      return;
     }
-    file->Close();
-    return;
   }
-  mEfficiencyMap = dynamic_cast<TH2D*>(rawMap->Clone("mEfficiencyMap"));
-  mEfficiencyMap->SetDirectory(nullptr); // Detach from file to avoid deletion when file is closed
 
-  file->Close();
+  map = dynamic_cast<TH2D*>(rawMap->Clone());
+  map->SetDirectory(nullptr); // Detach from file to avoid deletion when file is closed
+  LOG(info) << "Loaded " << mapName << " (" << map->GetNbinsX() << " x " << map->GetNbinsY() << " bins)";
+
+  if (file) {
+    file->Close();
+    delete file;
+  }
 }
 
 //_______________________________________________________________________
@@ -469,7 +521,7 @@ void Digitizer::registerDigits(Chip& chip, uint32_t roFrame, double time, int nR
   int tdc = int((time - nbc * o2::constants::lhc::LHCBunchSpacingNS) / digitizerParams.tdcBin);
   nbc += mEventTime.toLong();
 
-  double absoluteTime = tdc * digitizerParams.tdcBin + nbc * o2::constants::lhc::LHCBunchSpacingNS;
+  double absoluteTime = tdc * digitizerParams.tdcBin * 1.e-9 + nbc * o2::constants::lhc::LHCBunchSpacingNS;
 
   auto key = o2::iotof::Digit::getOrderingKey(nbc, tdc, row, col);
   o2::iotof::LabeledDigit* existingDigit = chip.findDigit(key);