diff --git a/algo/detectors/tof/Clusterizer.cxx b/algo/detectors/tof/Clusterizer.cxx
index 531796551d49c46bef29200513ba4392628d6272..930b3c2ad6d9e559ec344e5fabef01cc557dad28 100644
--- a/algo/detectors/tof/Clusterizer.cxx
+++ b/algo/detectors/tof/Clusterizer.cxx
@@ -16,30 +16,32 @@
 namespace cbm::algo::tof
 {
 
-  Clusterizer::resultType Clusterizer::operator()(const inputType& digisIn)
+  Clusterizer::resultType Clusterizer::operator()(const std::vector<std::pair<CbmTofDigi, int32_t>>& digisIn)
   {
     std::vector<inputType> input = chanSortDigis(digisIn);
     return buildClusters(input);
   }
 
-  std::vector<Clusterizer::inputType> Clusterizer::chanSortDigis(const inputType& digisIn)
+  std::vector<Clusterizer::inputType>
+  Clusterizer::chanSortDigis(const std::vector<std::pair<CbmTofDigi, int32_t>>& digisIn)
   {
     std::vector<inputType> result(fParams.fChanPar.size());  //[nbCh][nDigis]
 
     // Bucket-sort by channel
     for (size_t iDigi = 0; iDigi < digisIn.size(); iDigi++) {
-      CbmTofDigi* pDigi   = digisIn[iDigi].first;
-      const int32_t index = digisIn[iDigi].second;
-      const double chan   = pDigi->GetChannel();
+      const CbmTofDigi* pDigi = &digisIn[iDigi].first;
+      const int32_t index     = digisIn[iDigi].second;
+      const double chan       = pDigi->GetChannel();
       result[chan].emplace_back(pDigi, index);
     }
 
     /// Sort channel-wise by time
     for (size_t chan = 0; chan < fParams.fChanPar.size(); chan++) {
-      std::sort(result[chan].begin(), result[chan].end(),
-                [](const std::pair<CbmTofDigi*, int32_t>& a, const std::pair<CbmTofDigi*, int32_t>& b) -> bool {
-                  return a.first->GetTime() < b.first->GetTime();
-                });
+      std::sort(
+        result[chan].begin(), result[chan].end(),
+        [](const std::pair<const CbmTofDigi*, int32_t>& a, const std::pair<const CbmTofDigi*, int32_t>& b) -> bool {
+          return a.first->GetTime() < b.first->GetTime();
+        });
     }
     return result;
   }
@@ -93,9 +95,9 @@ namespace cbm::algo::tof
         if (2 > std::distance(digiIt, storDigi.end())) { break; }
 
         // 2 Digis = both sides present
-        cell               = &fParams.fChanPar[chan].cell;
-        CbmTofDigi* xDigiA = digiIt->first;
-        CbmTofDigi* xDigiB = std::next(digiIt)->first;
+        cell                     = &fParams.fChanPar[chan].cell;
+        const CbmTofDigi* xDigiA = digiIt->first;
+        const CbmTofDigi* xDigiB = std::next(digiIt)->first;
 
         // use local coordinates, (0,0,0) is in the center of counter  ?
         ROOT::Math::XYZVector pos(((-(double) numChan / 2. + (double) chan) + 0.5) * cell->sizeX, 0., 0.);
@@ -107,7 +109,7 @@ namespace cbm::algo::tof
 
         while (std::distance(digiIt, storDigi.end()) > 2 && std::abs(pos.Y()) > cell->sizeY * fParams.fPosYMaxScal) {
 
-          CbmTofDigi* xDigiC = std::next(digiIt, 2)->first;
+          const CbmTofDigi* xDigiC = std::next(digiIt, 2)->first;
 
           const double timeDifN = (xDigiC->GetSide() == xDigiA->GetSide()) ? xDigiC->GetTime() - xDigiB->GetTime()
                                                                            : xDigiC->GetTime() - xDigiA->GetTime();
diff --git a/algo/detectors/tof/Clusterizer.h b/algo/detectors/tof/Clusterizer.h
index 4d46a33b219ab10a4eb02d62c05fec72bf4e61a1..4ef616a6adbe01ddeec6475d827c49d29b48a81a 100644
--- a/algo/detectors/tof/Clusterizer.h
+++ b/algo/detectors/tof/Clusterizer.h
@@ -26,7 +26,6 @@ namespace cbm::algo::tof
   class Clusterizer {
   public:
     typedef std::tuple<std::vector<Hit>, std::vector<size_t>, std::vector<u32>, std::vector<int32_t>> resultType;
-    typedef std::vector<std::pair<CbmTofDigi*, int32_t>> inputType;
 
     /**
        ** @brief Constructor.
@@ -41,7 +40,7 @@ namespace cbm::algo::tof
     /**
        ** @brief Build clusters out of ToF Digis and store the resulting info in a TofHit.
        **/
-    resultType operator()(const inputType& digisIn);
+    resultType operator()(const std::vector<std::pair<CbmTofDigi, int32_t>>& digisIn);
 
     /** @brief Set the parameter container
      ** @param params Vectorer to parameter container
@@ -49,9 +48,11 @@ namespace cbm::algo::tof
     void SetParams(std::unique_ptr<ClusterizerRpcPar> params) { fParams = *(std::move(params)); }
 
   private:
+    typedef std::vector<std::pair<const CbmTofDigi*, int32_t>> inputType;
+
     ClusterizerRpcPar fParams = {};  ///< Parameter container
 
-    std::vector<inputType> chanSortDigis(const inputType& digisIn);
+    std::vector<inputType> chanSortDigis(const std::vector<std::pair<CbmTofDigi, int32_t>>& digisIn);
 
     resultType buildClusters(std::vector<inputType>& input);
 
diff --git a/algo/detectors/tof/Hitfind.cxx b/algo/detectors/tof/Hitfind.cxx
index be682c87bfa6e56afa330a2c71feef71ea66bae7..6445a02f85cd8586c860355409d05e67f10248f6 100644
--- a/algo/detectors/tof/Hitfind.cxx
+++ b/algo/detectors/tof/Hitfind.cxx
@@ -41,7 +41,7 @@ namespace cbm::algo::tof
         // Error already counted for monitoring during Digis calibration, so just discard here
         continue;
       }
-      fStorDigi[SmType][Sm * NbRpc + Rpc].push_back(std::make_pair(pDigi, idigi));
+      fStorDigi[SmType][Sm * NbRpc + Rpc].push_back(std::make_pair(*pDigi, idigi));
     }
 
     std::vector<Hit> clustersFlat;
@@ -56,7 +56,7 @@ namespace cbm::algo::tof
         for (uint32_t Rpc = 0; Rpc < NbRpc; Rpc++) {
 
           // Get digis
-          std::vector<std::pair<CbmTofDigi*, int32_t>>& digiExp = fStorDigi[SmType][Sm * NbRpc + Rpc];
+          std::vector<std::pair<CbmTofDigi, int32_t>>& digiExp = fStorDigi[SmType][Sm * NbRpc + Rpc];
 
           // Build clusters
           auto rpcresult              = fAlgo[SmType][Sm * NbRpc + Rpc](digiExp);
diff --git a/algo/detectors/tof/Hitfind.h b/algo/detectors/tof/Hitfind.h
index 951c32161e111d49509d2d1e89247c7885bbb3c1..995b9bdb105a1b10d46dd2a2a4931ff0a28ba95d 100644
--- a/algo/detectors/tof/Hitfind.h
+++ b/algo/detectors/tof/Hitfind.h
@@ -79,7 +79,7 @@ namespace cbm::algo::tof
     std::map<uint32_t, std::map<uint32_t, tof::Clusterizer>> fAlgo = {};  //[nbType][nbSm*nbRpc]
 
     /** @brief Intermediate storage variables (digi, index) **/
-    std::vector<std::vector<std::vector<std::pair<CbmTofDigi*, int32_t>>>> fStorDigi;  //[nbType][nbSm*nbRpc][nDigis]
+    std::vector<std::vector<std::vector<std::pair<CbmTofDigi, int32_t>>>> fStorDigi;  //[nbType][nbSm*nbRpc][nDigis]
 
     /** @brief Number of SMs per super module type **/
     std::vector<int32_t> fNbSm;